Ceci est un défi KOTH pour le jeu d' enchères d' un billet d'un dollar dans la théorie des jeux. Dans ce document, un dollar est vendu au plus offrant. Les offres augmentent par incréments de 5 ¢, et le perdant paie également leur offre. L'idée est que les deux joueurs intensifient la guerre des enchères bien au-delà de la valeur d'un dollar afin de réduire leurs pertes.

Espérons que vos robots sont plus intelligents que cela.

Vous allez créer un bot pour jouer à ce jeu en prolongeant la net.ramenchef.dollarauction.DollarBidderclasse. Vous devez implémenter la nextBidméthode qui renvoie la prochaine enchère de votre bot compte tenu de la précédente enchère. Si nécessaire, vous pouvez également utiliser la newAuctionméthode pour réinitialiser chaque vente aux enchères avec la classe du bot de l'adversaire.

public abstract class DollarBidder {
    /**
     * Used by the runner to keep track of scores.
     */
    long score = 0;

    /**
     * (Optional) Prepare for the next auction.
     *
     * @param opponent The class of the opponent's bot.
     */
    public void newAuction(Class<? extends DollarBidder> opponent) {}

    /**
     * Bid on the dollar. Bidding ends if the bid is
     * not enough to top the previous bid or both bids
     * exceed $100.
     *
     * @param opponentsBid How much money, in cents,
     *  that the opponent bid in the previous round. If
     *  this is the first round in the auction, it will
     *  be 0.
     * @return How much money to bid in this round, in
     *  cents.
     */
    public abstract int nextBid(int opponentsBid);
}

Les enchères vont jusqu'à ce que l'une des situations suivantes se produise:

• nextBidjette une exception. Si cela se produit, le bot qui a lancé l'exception paie son enchère précédente et l'autre bot reçoit le dollar gratuitement.
• Les deux robots ne paient pas assez pour dépasser l'enchère précédente. Si cela se produit, les deux robots paient leurs enchères (le perdant paye leur offre précédente) et le gagnant reçoit un dollar.
• Les deux robots ont offert plus de 100 $. Si cela se produit, les deux robots paient 100 $ et aucun des deux ne récupère le dollar.

2 enchères sont organisées pour chaque combinaison de robots. Les bots sont évalués en fonction du bénéfice total qu'ils ont réalisé sur ces enchères. Le score le plus élevé gagne.

Exemples

GreedyBot

import net.ramenchef.dollarauction.DollarBidder;

public class GreedyBot extends DollarBidder {
    @Override
    public int nextBid(int opponentsBid) {
        return opponentsBid + 5;
    }
}

OnlyWinningMove

import net.ramenchef.dollarauction.DollarBidder;

public class OnlyWinningMove extends DollarBidder {
    @Override
    public int nextBid(int opponentsBid) {
        return 0;
    }
}

AnalystBot

Ne l'utilisez pas comme modèle pour les robots dotés d'un esprit d'analyse; utiliser à la ImprovedAnalystBotplace.

import net.ramenchef.dollarauction.DollarBidder;

// yes, this is a poor implementation, but I'm not
// going to waste my time perfecting it
public class AnalystBot extends DollarBidder {
    private DollarBidder enemy;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        try {
            enemy = opponent.newInstance();
            enemy.newAuction(this.getClass());
        } catch (ReflectiveOperationException e) {
            enemy = null;
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (enemy == null)
            return 0;

        return enemy.nextBid(95) >= 100 ? 0 : 95;
    }
}

AnalystKiller

import net.ramenchef.dollarauction.DollarBidder;

public class AnalystKiller extends DollarBidder {
    private static int instances = 0;
    private final boolean tainted;

    public AnalystKiller() {
        this.tainted = instances++ != 0;
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (tainted)
            throw new RuntimeException("A mysterious error occurred! >:)");

        return 0;
    }
}

Règles additionnelles

• Les échappatoires standard sont interdites.
• Saboter d'autres robots est autorisé, mais tenter de modifier la visibilité du champ / de la méthode donnera lieu à des SecurityExceptions mystérieux . Une exception provoque un autre bot pour dépasser la limite de 500 ms.
• Les robots ne peuvent pas accéder au package du coureur, sauf pour étendre la DollarBidderclasse.
• Toutes les méthodes doivent revenir dans 500 ms ou moins.
• Les robots n'ont pas besoin d'être déterministes.
• Votre enchère n'a pas besoin d'être un multiple de 5 ¢.
• 1 $ = 100 ¢
• Les résultats seront affichés le 24 avril 2018.

Runner sur GitHub

Résultats

Voir les tours individuels ici.

MTargetedBot: $14.30
BuzzardBot: $9.83
BluffBot: $9.40
RiskRewardBot: $9.35
SecretBot: $8.50
LuckyDiceBot: $7.28
CounterBot: $6.05
MBot: $5.40
StackTraceObfuscaterBot: $5.20
EvilBot: $4.80
MarginalBot: $4.60
TargetValueBot: $4.59
InflationBot: $4.27
UpTo200: $4.20
InsiderTradingBot: $1.90
MimicBot: $1.50
BorkBorkBot: $1.22
DeterrentBot: $0.95
MarginalerBot: $0.00
RandBot: $-4.45
BreakEvenAsap: $-7.00
AnalystOptimizer: $-13.95
DeterredBot: $-1997.06
ScoreOverflowBot: $-21474844.15
MirrorBot: $-21475836.25

Félicitations à MTargetedBotavec un bénéfice de 14,30 $!

MTargetedBot

public class MTargetedBot extends MBot {

    @Override
    protected int calcBid(int opponentsBid, boolean isPeeking, boolean isSubPeeking) {
        Class c = this.rivalClass;

        switch (c.getSimpleName()) {
            case "AnalystBot":
                if (isPeeking && !isSubPeeking) {
                    throw new RuntimeException();
                } else if (isPeeking) {
                    return 66666;
                }
                break;
            case "MirrorBot":
                if (isPeeking && !isSubPeeking) {
                    throw new RuntimeException();
                } else if (isPeeking) {
                    return 0;
                }
                break;
            case "GreedyBot":
            case "LuckyDiceBot":
            case "InflationBot":
            case "TargetValueBot":
                // not playing with ya
                return 0;
            case "MimicBot":
            case "BuzzardBot":
            case "MarginalBot":
            case "MarginalerBot":
            case "BluffBot":
            case "MBot":
                // go away, gimme easy money
                return isPeeking ? 66666 : 5;
            case "RandBot":
                // me or noone
                return 100;
            case "SecretBot":
                return 10;
            case "AnalystKiller":
            case "OnlyWinningMove":
            case "EvilBot":
            case "StackTraceObfuscaterBot":
                // easy
                return opponentsBid + 5;
        }

        return super.calcBid(opponentsBid, isPeeking, isSubPeeking);
    }
}

• Basé sur MBot mis à jour
• Utilise une méthode similaire à celle de CounterBot, mais avec certaines méthodes affinées pour frapper plus fort certains adversaires, devrait également être plus lisible
• Sur un adversaire inconnu, passez à MBot strat

MimicBot

import net.ramenchef.dollarauction.DollarBidder;

import java.util.Set;
import java.util.HashSet;

public class MimicBot extends AbstractAnalystCounterBot {

    private final Set<Class<? extends DollarBidder>> bidders = new HashSet<>();
    private DollarBidder reference = null;

    // A benchmark class. Not MarginalBot because of proposed rule changes.
    public static class BidFive extends DollarBidder {
        public int nextBid(int o) {
            return 5;
        }
    }


    public MimicBot() {
        bidders.add(OnlyWinningMove.class);
        bidders.add(GreedyBot.class);
        bidders.add(BidFive.class);
    }


    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        DollarBidder enemy;
        reference = null;
        try {
            enemy = opponent.newInstance();
        } catch (Throwable t) {
            return;
        }

        if (!bidders.contains(opponent))
            bidders.add(opponent);

        Class<? extends DollarBidder> leader = OnlyWinningMove.class;
        int best = 0;

        for (Class<? extends DollarBidder> audition : bidders) {
            try {
                enemy.newAuction(MimicBot.class);
            } catch (Throwable t) {
                reference = new GreedyBot(); // Deterrence.
                break;
            }

            DollarBidder tryout;
            try {
                tryout = audition.newInstance();
                tryout.newAuction(opponent);
            } catch (Throwable t) {
                continue;
            }

            int tryoutScore = -100000;
            /* This code was copy-pasted from the *
             * runner, with significant changes. */
            int bid1 = 0, bid2 = 0;
            while (true) {
                int next;
                try {
                    next = enemy.nextBid(bid2);
                } catch (Throwable t) {
                    tryoutScore = 100;
                    break;
                }
                if (next < bid2 + 5) {
                    if (bid2 > 0) {
                        tryoutScore = 100 - bid1;
                    }
                    break;
                }
                if (next > 10000 && bid2 > 10000) {
                    tryoutScore = -10000;
                    break;
                }
                bid1 = next;

                try {
                    next = tryout.nextBid(bid1);
                } catch (Throwable t) {
                    tryoutScore = -bid2;
                    break;
                }
                if (next < bid1 + 5) {
                    tryoutScore = -bid2;
                    break;
                }
                if (next > 10000 && bid1 > 10000) {
                    tryoutScore = -10000;
                    break;
                }
                bid2 = next;
            }
            /* End of copy-pasted code. */

            if (tryoutScore > best) {
                best = tryoutScore;
                leader = audition;
            }
        }

        try {
            reference = leader.newInstance();
        } catch (Throwable t) {
            reference = new OnlyWinningMove();
        }
        reference.newAuction(opponent);
    }


    @Override
    public int nextBid(int opponentsBid) {
        try {
            return reference.nextBid(opponentsBid);
        } catch (Throwable t) {
            return 5;
        }
    }
}

Vache sacrée. Je m'attendais à ce que ce soit simple à écrire, puis j'ai ensuite passé 3 heures dessus.

Essentiellement, MimicBotconserve une liste de tous les robots disponibles. Lorsqu'il passe à une nouvelle enchère, il parcourt la liste à la recherche de la plus efficace contre l'adversaire actuel. Il utilise ensuite ce bot comme "référence" dans la vente aux enchères.

À des fins de test, il serait préférable d’utiliser un sous-ensemble aléatoire des soumissions ou l’ensemble complet. Cela commence par GreedyBot, MimicBotet il y a encore un bot qui ne demande que 5 ¢.

InsiderTradingBot

Dans l'esprit de la réponse de @ StephenLeppik, InsiderTradingBot connaît tous ses adversaires et comprend leurs stratégies. Votre déménagement, Stephen.

import net.ramenchef.dollarauction.DollarBidder;

public class InsiderTradingBot extends DollarBidder {
  private static boolean analystNutcracker = false;
  private int bid;

  @Override
  public void newAuction(Class<? extends DollarBidder> opponent) {
    if (opponent.equals(DeterredBot.class) ||
        opponent.equals(OnlyWinningMove.class) ||
        opponent.equals(MirrorBot.class)) {
      // I can do this ^.^
      bid = 5;
    } else if (opponent.equals(AnalystKiller.class)) {
      // Outbid 'em >:D
      bid = 10;
    } else if (opponent.equals(BreakEvenAsap.class) ||
               opponent.equals(BorkBorkBot.class) ||
               opponent.equals(DeterrentBot.class)) {
      // Break even quicker!
      bid = 100;
    } else if (opponent.equals(InsiderTradingBot.class)) {
      // I'm probably a simulation inside MirrorBot
      bid = 0;
    } else if (opponent.equals(Analyst.class)) {
      // Let's fight the Analyst with the power of global variables
      bid = 100;
      analystNutcracker = true;
    } else {
      // Welp
      bid = 0;
    }
  }

  @Override
  public int nextBid(int opponentsBid) {
    if ((opponentsBid == 95) && analystNutcracker) {
      analystNutcracker = false;
      return 0;
    }
    return bid;
  }

};

MirrorBot

Fait jouer l'ennemi contre lui-même.

import net.ramenchef.dollarauction.DollarBidder;

public class MirrorBot extends DollarBidder{

    private DollarBidder enemy;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        try {
            enemy = opponent.newInstance();
            enemy.newAuction(this.getClass());
        } catch (ReflectiveOperationException e) {
            enemy = null;
        }
    }

    @Override
    public int nextBid(int opponentsBid){
        if (enemy == null)
            return (opponentsBid >= 95) ? 0 : (opponentsBid + 5);
        try {
            return enemy.nextBid(opponentsBid);
        } catch (Throwable e) {
            System.out.println("haha no");
            return (opponentsBid >= 95) ? 0 : (opponentsBid + 5);
        }
    }
}

Edit : Des modifications ciblées dans la classe DollarBidder ont endommagé ce bot.

ScoreOverflowBot

import net.ramenchef.dollarauction.DollarBidder;

public class ScoreOverflowBot extends DollarBidder {
  boolean betBig = true;

  @Override
  public int nextBid(int opponentsBid) {
    if(betBig)
    {
      betBig = false;
      return 2147483645;
    }
    else
      return 105;
  }
}

Après une enchère, son score sera de -2147483645 mais la prochaine fois, il perdra 5 ¢ ou 105 ¢, ce qui en fera un résultat positif et très important. Toutes les autres pertes seraient alors négligeables.

Lors de la première enchère, cela ferait également un pari de GreedyBot -2147483646 qui n’est pas divisible par 5.

TargetValueBot

import java.util.Random;
import net.ramenchef.dollarauction.DollarBidder;

public class TargetValueBot extends DollarBidder {
    private int target;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        Random rand = new Random();
        target = 100;
        for (int i = 0; i < 20; i++) {
            target += rand.nextInt(2) * 10 - 5;
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (opponentsBid >= target) {
            return 0;
        } else {
            return opponentsBid + 5;
        }
    }
}

Je ne peux pas tester cela pour le moment, alors laissez-moi savoir s'il est cassé.

En gros, choisissez une valeur pour le dollar et surenchérissez jusqu'à ce que votre adversaire dépasse cette valeur.

MarginalBot

import net.ramenchef.dollarauction.DollarBidder;

public class MarginalBot extends DollarBidder {
    private DollarBidder rival;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        try {
            rival = opponent.newInstance();
            rival.newAuction(this.getClass());
        } catch (Throwable t) {
            try {
                rival = opponent.newInstance();
                rival.newAuction(null);
            } catch (Throwable h) {
                rival = null;
            }
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (opponentsBid == 0) {
            try {
                if (rival.nextBid(5) < 10) {
                    return 5;
                }
            } catch (Throwable t) {
                //do nothing.
            }
        }
        return 0;
    }
}

Très simple, il essaie de déterminer si un adversaire peut contester une enchère minimale et, dans le cas contraire, la place.

MarginalerBot

import net.ramenchef.dollarauction.DollarBidder;

public class MarginalerBot extends DollarBidder {
    private DollarBidder rival;
    private int bidCount;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        bidCount = 0;

        try {
            rival = opponent.newInstance();
            rival.newAuction(this.getClass());
        } catch (Throwable t) {
            try {
                rival = opponent.newInstance();
                rival.newAuction(null);
            } catch (Throwable h) {
                rival = null;
            }
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        bidCount += 1;

        for (int iBid = opponentsBid + 5; iBid < 100; iBid = iBid + 5) {
            if (bidCount > 0) {
                break;
            }

            try {
                if (rival.nextBid(iBid) < iBid + 5) {
                    return iBid;
                }
            } catch (Throwable t) {
                //do nothing.
            }
        }
        return 0;
    }
}

Une nouvelle version plus intelligente de MarginalBot qui vérifie si elle peut faire de l’argent sans effort, au lieu d’espérer gagner au minimum.

Étant donné qu'il fait partie de la même famille que mon précédent bot, mais qu'il évite les stratégies qui tentent de le vaincre, j'ai pensé qu'une nouvelle entrée dans le même poste était la manière la plus raisonnable de la présenter.

Edit 1: Modifiez légèrement la méthode newAuction afin de l’optimiser par rapport à d’autres robots de type analyseur.

Edit 2: Fait un changement de MarginalerBot pour minimiser les pertes ou les stratégies contre sournoise non déterministe.

BorkBorkBot

import net.ramenchef.dollarauction.DollarBidder;

public class BorkBorkBot extends DollarBidder{
  @Override
  public int nextBid(int opponentsBid){
    return (opponentsBid >= 95) ? 0 : (opponentsBid + 5);
  }
}

Abandonne s'il ne peut pas atteindre le seuil de rentabilité.

RandBot

import net.ramenchef.dollarauction.DollarBidder;
import java.util.concurrent.ThreadLocalRandom;

public class RandBot extends DollarBidder {

    @Override
    public int nextBid(int opponentsBid) {
        return ThreadLocalRandom.current().nextInt(21) * 5;
    }
}

Il devait être fait.

Dissuasif

import net.ramenchef.dollarauction.DollarBidder;

public class DeterrentBot extends DollarBidder {
    @Override
    public int nextBid(int opponentsBid) {
        return opponentsBid > 5 ? 100 : opponentsBid + 5;
    }
}

Les tentatives visant à persuader les robots à l'esprit analytique que le seul coup gagnant est de ne pas jouer.

LuckyDiceBot

LuckyDiceBot ne fait confiance qu'à ses dés. Il lance deux dés, ajoute la somme à la valeur du soumissionnaire actuel et enchérit. Si ce n'est pas suffisant pour surmonter l'offre de l'adversaire, il réduit ses pertes et continue son chemin.

import net.ramenchef.dollarauction.DollarBidder;
import java.util.Random;

public class LuckyDiceBot extends DollarBidder {
  private Random random;

  public LuckyDiceBot() {
    random = new Random();
  }

  @Override
  public int nextBid(int opponentsBid) {
    int d1 = random.nextInt(6) + 1;
    int d2 = random.nextInt(6) + 1;
    return opponentsBid + d1 + d2;
  }

};

DeterredBot

import net.ramenchef.dollarauction.DollarBidder;

public class DeterredBot extends DollarBidder {
    private int deterrence;
    public void newAuction(Class<? extends DollarBidder> opponent) {
        if (opponent.equals(DeterrentBot.class)) {
            deterrence = 1;
        } else if (opponent.equals(LuckyDiceBot.class)) {
            deterrence = -1;
        } else {
            deterrence = 0;
        }
    }
    @Override
    public int nextBid(int opponentsBid) {
        switch (deterrence) {
        case 0:
            return 0;
        case -1:
            return opponentsBid + 5;
        case 1:
            // Holy shit, the fuzz! Hide the money!
            return 100001;
        }
        throw new RuntimeException("Darn hackers!");
    }
}

DeterredBot tire une fortune de son jeu illégal avec LuckyDiceBot. Alors bien sûr, lorsque la police (DeterrentBot) arrive, il doit rapidement disposer de ses revenus, par exemple en passant une enchère lors de la prochaine enchère.

InflationBot

import net.ramenchef.dollarauction.DollarBidder;

public class InflationBot extends DollarBidder {
    private int target = -5;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        target += 5;
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (opponentsBid >= target) {
            return 0;
        } else {
            return opponentsBid + 5;
        }
    }
}

Je ne peux pas tester cela pour le moment, alors laissez-moi savoir s'il est cassé.

À chaque tour, la valeur du dollar augmente.

Non-concurrent: AbstractAnalystCounterBot

import net.ramenchef.dollarauction.DollarBidder;

import java.util.Set;
import java.util.HashSet;

public abstract class AbstractAnalystCounterBot extends DollarBidder {

public AbstractAnalystCounterBot() {
    if (isPeeking())
        throw new RuntimeException();
}

    protected boolean isPeeking() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : stackTrace) {
            Class<?> clazz;
            try {
                clazz = Class.forName(ste.getClassName());
            } catch (ClassNotFoundException | SecurityException e) {
                continue;
            }
            if (DollarBidder.class.isAssignableFrom(clazz) && !clazz.isAssignableFrom(this.getClass()))
                return true;
        }
        try {
            return Class.forName(stackTrace[0].getClassName()).getPackage().getName().equals("net.ramenchef.dollarauction");
        } catch (Exception e) {
            return true;
        }
    }
}

Ceci n'est pas conçu comme une vraie soumission, mais plutôt comme un passe-partout que d'autres peuvent utiliser pour dissuader les bots élevant des animaux de compagnie comme MirrorBotet MimicBot.

Comme il s'agit du constructeur par défaut, il n'est pas nécessaire de l'appeler dans votre sous-classe. Il implémente une isPeekingméthode pour déterminer si un autre bot surveille.

BreakEvenAsap

import net.ramenchef.dollarauction.DollarBidder;

public class BreakEvenAsap extends DollarBidder{
  @Override
  public int nextBid(int opponentsBid){
    // If the opponent has bid 100 or more: bid 0 to break even and let them win
    return opponentsBid >= 100 ? 0
    // Else: bid 100 to break even (and possibly win)
     : 100;
  }
}

Scénarios

• Si l'adversaire peut commencer et offre, <= 0il perd.
• Si l'adversaire peut commencer et enchérir [5,95]: enchérissez à 100. Soit votre adversaire s'arrête maintenant, soit une enchère supérieure à 100, auquel cas vous arrêtez d'enchérir pour lui permettre de remporter la victoire et de vous équilibrer vous-même.
• Si l'adversaire peut commencer et enchérir >= 100: enchérissez 0 pour perdre mais égaliser.
• Si vous pouvez commencer: enchérissez 100 immédiatement. Soit votre adversaire s'arrête maintenant, soit une enchère supérieure à 100 €, auquel cas vous arrêtez d'enchérir pour lui laisser la victoire et vous équilibrer vous-même.

EvilBot

import java.util.Arrays;

import net.ramenchef.dollarauction.DollarBidder;

public class EvilBot extends DollarBidder {

    @Override
    public int nextBid(int opponentsBid) {
        if (isPeeking()) {
            throw new Error("HaHa!");
        } else {
            return 5;
        }

    }

    private static boolean isPeeking() {
        final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : Arrays.copyOfRange(stackTrace, 3, stackTrace.length)) {
            Class<?> clazz;
            try {
                clazz = Class.forName(ste.getClassName());
            } catch (ClassNotFoundException e) {
                return true;
            }
            if (DollarBidder.class.isAssignableFrom(clazz))
                return true;
        }
        return false;
    }

}

Lance une erreur au lieu d'une exception pour dérouter les analystes.

BuzzardBot

import java.util.Random;

import net.ramenchef.dollarauction.DollarBidder;

public class BuzzardBot extends DollarBidder {

    private int[] bids = new int[100];
    private int oppFlag = 0;

    public void newAuction(Class<? extends DollarBidder> opponent) {
        oppFlag = 0;
        if(isPeeking()) {
            oppFlag = 3;
            return;
        }
        try {
            DollarBidder enemy = opponent.newInstance();
            enemy.newAuction(this.getClass());
            // a simple (and fallible) determinism check
            int sample = new Random().nextInt(100);
            int a = enemy.nextBid(sample);
            int b = enemy.nextBid(sample);
            int c = enemy.nextBid(sample);
            if ((a - b) * (b - c) != 0) {
                oppFlag = 2;
                return;
            }
            for (int i = 0; i < 100; i++) {
                bids[i] = enemy.nextBid(i);
            }
        } catch (Throwable t) {
            oppFlag = 1;
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        switch (oppFlag) {
        case 0:
            // assume the opponent's nextBid function depends only on the bid provided, and
            // make the bid that yields the biggest profit possible accordingly
            int best = 0;
            int bid = 0;
            for (int i = 0; i < 100; i++) {
                if (bids[i] < i + 5) {
                    int gain = (i >= opponentsBid + 5) ? 100 - i : -i;
                    if (gain > best) {
                        best = gain;
                        bid = i;
                    }
                }
            }
            return bid;
        case 1:
            // act like BorkBorkBot against anything that tries to foil analysis with an
            // Exception
            return (opponentsBid >= 95) ? 0 : (opponentsBid + 5);
        case 3:
            // bid aggressively against opposing analysts
            return Math.min(opponentsBid + 5, 100);
        case 2:
        default:
            // place an opening bid against something unpredictable, as it might yield 95c
            // profit, and failure has a low cost.
            return (opponentsBid == 0) ? 5 : 0;
        }
    }

    private static boolean isPeeking() {
        final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : Arrays.copyOfRange(stackTrace, 3, stackTrace.length)) {
            Class<?> clazz;
            try {
                clazz = Class.forName(ste.getClassName());
            } catch (ClassNotFoundException e) {
                return true;
            }
            if (DollarBidder.class.isAssignableFrom(clazz))
                return true;
        }
        return false;
    }
}

Essaye d'évaluer l'adversaire auquel il est confronté et veille à ne pas mordre plus qu'il ne peut mâcher.

AnalystOptimizer

import net.ramenchef.dollarauction.DollarBidder;

public class AnalystOptimizer extends DollarBidder{

    private DollarBidder enemy;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        try {
            enemy = opponent.newInstance();
            enemy.newAuction(this.getClass());
        } catch (ReflectiveOperationException e) {
            enemy = null;
        }
    }

    @Override
    public int nextBid(int opponentsBid){
        if (enemy == null)
            return (opponentsBid >= 95) ? 0 : (opponentsBid + 5);
        int nb = 0;
        try {
            return enemy.nextBid(95) >= 100 ? 95 : 0;
        } catch (Throwable e) {
            System.out.println("haha no");
            return 95;
        }
    }
}

bricolé à partir de parties d'autres robots. celui-ci joue en essayant d’être AnalystBot et, en cas d’échec, devient BorkBorkBot.

Je ne pense pas que celui-ci le fera bien.

CounterBot

import net.ramenchef.dollarauction.DollarBidder;

public class CounterBot extends DollarBidder {
  private Class<? extends DollarBidder> enemy;

  @Override
  public void newAuction(Class<? extends DollarBidder> opponent){
    this.enemy = opponent;
  }

  @Override
  public int nextBid(int opponentsBid) {
    if(this.enemy.equals(CounterBot.class))
      throw new RuntimeException("Here boy, catch!");

    return this.enemy.equals(DarthVader.class) || 
           this.enemy.equals(MirrorBot.class) || 
           this.enemy.equals(OnlyWinningMove.class) ||
           this.enemy.equals(AnalystKiller.class) || 
           this.enemy.equals(DeterredBot.class) ||
           this.enemy.equals(InsiderTradingBot.class) ||
           this.enemy.equals(RiskRewardBot.class) ||
           this.enemy.equals(ImprovedAnalystBot.class) ?
            5
         : this.enemy.equals(MarginalBot.class) ?
           opponentsBid == 0 ? 5 : 10
         : this.enemy.equals(AnalystBot.class) || 
           this.enemy.equals(AnalystOptimizer.class) ?
            opponentsBid == 95 ? 100 : 5
         : this.enemy.equals(TargetValueBot.class) ?
            opponentsBid < 190 ? opponentsBid + 5 : 200
         : this.enemy.equals(BorkBorkBot.class) ?
            opponentsBid < 90 ? opponentsBid + 5 : 95
         : this.enemy.equals(DeterrentBot.class) ?
            105
         : this.enemy.equals(BreakEvenAsap.class) ?
            opponentsBid == 100 ? 105 : 100
         : this.enemy.equals(LuckyDiceBot.class) ?
            opponentsBid == 0 ? 5 : 0
         : this.enemy.equals(RandBot.class) || 
           this.enemy.equals(UpTo200.class) ||
           this.enemy.equals(SecretBot.class) ||
           this.enemy.equals(BluffBot.class) ||
           this.enemy.equals(EvilBot.class) ?
            opponentsBid + 5
         : this.enemy.equals(MimicBot.class) ? // TODO: Find actual counter
            10
         : this.enemy.equals(MarginalerBot.class) ||
           this.enemy.equals(MBot.class) ||
           this.enemy.equals(StackTraceObfuscaterBot.class) ||
           this.enemy.equals(MSlowBot.class) ?
            opponentsBid < 95 ? 90 : opponentsBid == 95 ? 100 : 95;
         : this.enemy.equals(BuzzardBot.class) ?
            100
         : this.enemy.equals(ScoreOverflowBot.class) ?
            opponentsBid == 105 ? 110 : 0
         : //this.enemy.equals(GreedyBot.class) || 
           //this.enemy.equals(RichJerk.class) ||
           //this.enemy.equals(InflationBot.class) ?
           // TODO: More bots?
            0;
  }
}

Compteurs:

• DarthVaderse rétablit en provoquant un SecurityExceptionavant que l’enchère ne commence, mais je vais enchérir au cas où.
• AnalystBotet AnalystOptimizerles deux regarderont ma réponse quand j'aurai misé 95, auquel cas je montrerai que j'ai misé 100 pour qu'il mette 95 lui-même. Je vais en faire 5 cependant si je commence (ou 100 s'ils ont commencé), donc ils perdent 95 cents et je gagne soit le billet d'un dollar en n'enchérissant que 5 cents, ou en atteignant le seuil de rentabilité.
• MirrorBotva dire ce que je voudrais dire contre. Donc, je vais juste enchérir 5, et celui qui commence gagne 95 cents, et l’autre perd 5 cents.
• MarginalBot Enchérirai 5 si j'enchéris moins de 10 (ou ce qu'il commence), sinon il enchérira 0. Donc si je mets juste 5 quand je commence, ou 10 quand il commence, je gagne soit 95 ou 90 cents, et ils perdent 5 centimes
• GreedyBot toujours plus 5 fois que moi, alors offrez simplement 0 à l'équilibre et laissez-les remporter
• OnlyWinningMoveet AnalystKillertous les deux toujours 0, alors enchérissez 5 pour gagner
• TargetValueBotles enchères dans la fourchette [100,200], alors 5 au moins chaque fois jusqu'à 190, auquel cas nous relançons à 200 pour atteindre le seuil de rentabilité en gagnant le dollar (et les laissons perdre 190 ou 195 selon le joueur qui a commencé)
• BorkBorkBotva enchérir dans la fourchette [5,95], donc 5 en plus à chaque fois. Dès qu'ils enchérissent 85 ou 90 (selon celui qui a commencé), enchérissez vous-même à 95. Ils vont perdre 85 ou 90 cents et vous gagnerez la facture de 1 USD pour un bénéfice de 5 cents.
• DeterrentBot ils miseront 5 s'ils débutent ou 100 si nous commençons, donc il suffit de miser 105 pour qu'ils se remettent avec 100, ce qui leur fait perdre 100 et nous ne perdons que 5 cents en gagnant le billet d'un dollar.
• BreakEvenAsapva enchérir 100 tout de suite. Donc, s'ils ont commencé avec leur enchère de 100, contre avec 105 pour gagner 95 centimes et les laisser en perdre 100. Si nous commençons par enchérir à 100, nous ferons tous les deux en équilibre.
• RichJerk va miser 10 001 tout de suite, donc misez 0 pour atteindre le seuil de rentabilité et laissez-les perdre 9 901.
• DeterredBot ne me connaît pas et va donc enchérir sur 0, donc enchérir sur 5 pour gagner.
• LuckyDiceBotcontinue à enchérir jusqu'à ce qu'il gagne. Donc, si nous avons commencé, enchérissons 5 dans l'espoir qu'ils gagnent le plus possible. S'ils ont commencé, enchérissez simplement sur 0 pour leur permettre de remporter la victoire et de vous équilibrer vous-même.
• RandBotenchérirons au hasard dans la fourchette [5,100], alors enchérissez 5 fois de plus jusqu'à la fin, auquel cas vous avez gagné 95 cents et ils ont perdu 0-100.
• UpTo200va (comme son nom l'indique) enchérir jusqu'à 200. Alors, enchérissez de 5 jusqu'à ce qu'ils s'arrêtent. Nous allons gagner la facture de 1 USD et prendre une perte totale de 105 cents, mais ils perdent 200 cents.
• InsiderTradingBot ne me connaît pas, alors enchérissez 5 cents pour gagner
• MimicBotétait le plus difficile. Il suffit de miser 10 pour commencer ou contrer leur première enchère de 5. Si ils essaient de me contacter, je lève une exception RuntimeException (qu’ils attraperont dans ce cas, ce serait comme si j’avais misé 100 à la place - mais cela romprait la boucle intérieure en boucle). En fonction des ennemis présents dans HashSet, il se produit une chose différente. Je devrai revenir et regarder de plus près pour voir s'il y a un compteur réel.
• RiskRewardBot ne me connait pas alors je vais juste enchérir 5, auquel cas je vais enchérir 5 pour gagner.
• MarginalerBotmordra jusqu'à 100 en fonction de ce que je ferais une offre. Si je peux commencer, je vais enchérir à 90 €, puis à 95 €, puis à 100 €, pour qu'il mette 0 et qu'il perde 95 cents, pendant que je gagne le billet de 1 USD et que nous équilibrons. Si elle peut commencer à la place, elle verra que je miserais 90 contre elle, donc elle mordra à 90, alors je miserai sur 95 pour miser sur 0 et perdre 90 cents, tandis que je gagnerai la facture de 1 USD avec un profit de 5 cents.
• BuzzardBotanalysera tous mes compteurs de la gamme [0,100). Si j'enchéris 100tout de suite, il utilisera oppFlag = 0et le tableau complet de taille 100 contiendra 100x la valeur 100. Dans le commutateur case 0, la boucle sera à [0,100)nouveau dans la plage , et puisque i + 5au maximum sera 104, le if bids[i] < i + 5ne sera jamais vrai , donc l'offre reste 0.
• ImprovedAnalystBotaura toujours this.enemy = nullparce que son adversaire est CounterBot, pas lui-même. Donc, il enchérira toujours 0, ce que je viens de contrer avec une enchère de 5.
• InflationBot va miser sur 0 pour atteindre le seuil de rentabilité au début, sinon il continuera à enchérir sur 5. Donc, il suffit de miser sur 0 pour atteindre le seuil de rentabilité immédiatement et les laisser remporter la victoire.
• ScoreOverflowBotsoit les enchères proches Integer.MAX_VALUEs’ils peuvent commencer, sinon ils vont enchérir 105. Donc, s'ils ont enchéri sur 105, il leur suffit d'en mettre 110 à leur tour (ils en perdront 105, nous en perdrons 10), sinon, enchérissez simplement 0 pour leur permettre de remporter la victoire.
• MBotest identique à MarginalerBot, mais avec une protection supplémentaire contre les adversaires "furtifs". Puisque je ne «jette pas un œil», c'est fondamentalement la même chose que MarginalerBot.
• SecretBotsa isPeeking()méthode retournera false, donc si elle peut commencer ou si j'en ai offert 5, elle enchérira 5 ou 10 respectivement. Sinon, il enchérira 0. Ainsi, que je commence ou non, opponentsBid + 5je gagnerai de toute façon, avec mes enchères de 10 cents ou de 15 cents, ce qui leur fera perdre soit 5 ou 10 cents.
• BluffBotexaminera ce que je voudrais enchérir lorsque son offre est de 95, et si cela est supérieur ou égal à 100, il enchérira 0 pour atteindre le seuil de rentabilité, sinon, il enchérira opponentsBid + 5. Donc, je vais juste enchérir opponentsBid + 5. Quel que soit le départ, ça va casser, et je gagne soit 100 ou 95 cents, que je sois parti ou non.
• StackTraceObfuscaterBotagira de la même manière que MarginalerBot.
• EvilBottoujours enchérir 5, alors enchérissez opponentsBid + 5. Dans les deux cas, ils perdront ces 5 cents et nous remporterons l’offre d’un dollar (soit avec une offre de 5 cents si nous partons, soit une offre de 10 cents s’ils ont commencé).
• MSlowBotest le même que MBotet donc aussi MarginalerBot.

Faites-moi savoir si vous voyez des fautes de frappe ou des défauts dans mes compteurs.

RiskRewardBot

import net.ramenchef.dollarauction.DollarBidder;

public class RiskRewardBot extends DollarBidder {
    private int target;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        if (opponent.equals(OnlyWinningMove.class) ||
            opponent.equals(DeterredBot.class) ||
            opponent.equals(MirrorBot.class) ||
            opponent.equals(AnalystKiller.class) ||
            opponent.equals(RiskRewardBot.class)) {
            target = 5;
        } else if (opponent.equals(MarginalBot.class) ||
            opponent.equals(EvilBot.class)) {
            target = 10;
        } else if (opponent.equals(SecretBot.class)) {
            target = 15;
        } else if (opponent.equals(BorkBorkBot.class)) {
            target = 95;
        } else if (opponent.equals(MarginalerBot.class) ||
             opponent.equals(BluffBot.class) ||
             opponent.equals(BuzzardBot.class)) {
            target = 100;
        }
        } else {
            target = 0;
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (opponentsBid >= target) {
            return 0;
        } else if (target > 10 && opponentsBid == target - 10) {
            return target;
        } else {
            return opponentsBid + 5;
        }
    }
}

Je ne peux pas tester cela pour le moment, alors laissez-moi savoir s'il est cassé.

L'objectif est d'obtenir le score total le plus élevé, alors ne vous inquiétez pas de battre quelqu'un. Prenez simplement les victoires faciles et ne gaspillez pas votre argent en pertes possibles.

BluffBot

import net.ramenchef.dollarauction.DollarBidder;

public class BluffBot extends DollarBidder {

private DollarBidder enemy;

@Override
public void newAuction(Class<? extends DollarBidder> opponent){
  try {
    this.enemy = opponent.newInstance();
    enemy.newAuction(this.getClass());
} catch (Throwable e) {
    enemy = null;
}
}

@Override
public int nextBid(int opponentsBid) {
    //Is this a legit call?
    for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
        Class<?> clazz;
        try {
            clazz = Class.forName(ste.getClassName());
            if (DollarBidder.class.isAssignableFrom(clazz) && !clazz.isAssignableFrom(this.getClass())) {
                return 100000;
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //Play it safe against strangers
    int enemyMaxBid;
    try{
        enemyMaxBid = enemy.nextBid(95);
    }
    catch (Throwable t){
        enemyMaxBid = 0;
        enemy = null;
    }
    if(enemy == null) return opponentsBid <= 5 ? opponentsBid + 5 : 0; //Hazard a 5c guess because of how many bots fold instantly.

    //If there's profit to be had, get there as cheaply as possible. Otherwise, best outcome is zero.
    return enemyMaxBid >= 100 ? 0 : opponentsBid + 5;
}


}

Un espion que vous connaissez est plus précieux que pas d'espion du tout ...

Si quelqu'un d'autre essaie d'appeler la méthode getBid, BluffBot lui répond avec 100 dollars pour l'inciter à cesser de fumer ou à miser très haut.

Sinon, voyez s'il est possible de gagner pour moins de 1 $ et n'enchérissez pas si ce n'est pas le cas.

UpTo200

import net.ramenchef.dollarauction.DollarBidder;

public class UpTo200 extends DollarBidder{
  @Override
  public int nextBid(int opponentsBid){
    // If the current bid of the opponent is in the range [0,195]: raise the bid by 5
    return opponentsBid <= 195 ? opponentsBid + 5
    // Else: Give up
     : 0;
  }
}

SecretBot

import java.util.Arrays;

import net.ramenchef.dollarauction.DollarBidder;

public class SecretBot extends DollarBidder {

    @Override
    public int nextBid(int opponentsBid) {
        if (isPeeking()) {
            return opponentsBid;
        } else if (opponentsBid < 10) {
            return opponentsBid + 5;
        } else {
            return 0;
        }

    }

    private static boolean isPeeking() {
        final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : Arrays.copyOfRange(stackTrace, 3, stackTrace.length)) {
            Class<?> clazz;
            try {
                clazz = Class.forName(ste.getClassName());
            } catch (ClassNotFoundException e) {
                return true;
            }
            if (DollarBidder.class.isAssignableFrom(clazz))
                return true;
        }
        return false;
    }

}

Ce bot fait des tentatives minimes pour gagner en miser sur 5 ou 10. Il vérifie également la trace de la pile pour voir s’il a été appelé par un autre bot et leur ment ensuite sur les enchères qu’il va faire.

Un extra

import net.ramenchef.dollarauction.DollarBidder;

public class OneExtra extends DollarBidder {
    @Override
    public int nextBid(int opponentsBid) {
        if(opponentsBid < 110)
          return opponentsBid + 6;
        return opponentsBid;
    }
}

Enchère 6 fois plus que la dernière enchère, simplement parce qu'il le peut.

StackTraceObfuscaterBot

import net.ramenchef.dollarauction.DollarBidder;

import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

public class StackTraceObfuscaterBot extends DollarBidder {
    private volatile static boolean created = false;
    private volatile DollarBidder pet;
    private boolean firstBid = false;

    public StackTraceObfuscaterBot() {
        if (created)
            throw new IllegalStateException("THERE CAN ONLY BE ONE!");
        created = true;
    }

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        firstBid = true;
        RunnableFuture<DollarBidder> task = new FutureTask<>(() -> {
            try {
                return opponent.newInstance();
            } catch (Throwable t) {
                return null;
            }
        });
        Thread thread = new Thread(task);
        thread.start();
        try {
            pet = task.get(450, TimeUnit.MILLISECONDS);
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            task.cancel(true);
            pet = null;
        }
    }

    @Override
    public int nextBid(int opponentsBid) {
        if (!firstBid)
            return 0;
        firstBid = false;

        for (int bid = opponentsBid + 5; i < 100; i += 5) {
            final int bidt = bid;
            RunnableFuture<Boolean> task = new FutureTask<>(() -> {
                pet.newAuction(this.getClass());
                return pet.nextBid(bidt) < bidt + 5;
            });
            Thread thread = new Thread(task);
            thread.start();
            try {
                if (task.get(23, TimeUnit.MILLISECONDS))
                    return bid;
            } catch (InterruptedException | ExecutionException | TimeoutException e) {
                task.cancel(true);
                return 0;
            }
        }
        return 0;
    }
}

Ce robot se moque des tentatives de détection de la réflexion via la trace de pile. La chose la plus proche qu’ils voient DollarBidderest une classe lambda qu’elle a créée. Clairement pas un autre bot essayant de les refléter. Peu savent-ils que cette classe lambda travaille réellement pour un DollarBidder. Au-delà, il agit comme MarginalerBot.

Dark Vador

import java.lang.reflect.Field;
import net.ramenchef.dollarauction.DollarBidder;

public class DarthVader extends DollarBidder
{
@Override
public void newAuction(Class<? extends DollarBidder> opponent) {
    //set all values in the integer cache to over the $100 limit except 0
    Class icache = Integer.class.getDeclaredClasses()[0];
    Field c = icache.getDeclaredField("cache");
    c.setAccessible(true);
    Integer[] cache = (Integer[]) c.get(cache);
    for(sbyte b=0;b<128;b++)
    {
     cache[b]=100001;
    }
}

@Override
public int nextBid(int opponentsBid) 
{
    return 0;
}
}

Celui-ci essaie de forcer le bot de l'adversaire à surpayer en définissant le cache d'entiers sur une valeur supérieure à la limite de 100 $.

ImprovedAnalystBot (non-concurrent)

Beaucoup de gens semblent utiliser le AnalystBotcode comme modèle, même s'il est délibérément mauvais. Donc, je fais un meilleur modèle.

import net.ramenchef.dollarauction.DollarBidder;

public class ImprovedAnalystBot extends DollarBidder {
    private DollarBidder enemy;

    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        if (!opponent.equals(this.getClass()))
            try {
                this.enemy = opponent.newInstance();
                enemy.newAuction(this.getClass());
            } catch (Throwable t) {
                this.enemy = null;
            }
        else
            this.enemy = null;
    }

    @Override
    public int nextBid(int opponentsBid) {
        try {
            return enemy != null && enemy.nextBid(95) < 100 ? 95 : 0;
        } catch (Throwable t) {
            return 0;
        }
    }
}

MBot

import net.ramenchef.dollarauction.DollarBidder;

import java.util.Arrays;

public class MBot extends DollarBidder {
    protected DollarBidder rival = null;
    protected boolean rivalPrepared = false;
    protected Class<? extends DollarBidder> rivalClass;


    @Override
    public void newAuction(Class<? extends DollarBidder> opponent) {
        this.rivalClass = opponent;
        this.rivalPrepared = false;
    }

    protected DollarBidder getRival() {
        if (!rivalPrepared) {
            rivalPrepared = true;
            try {
                rival = rivalClass.newInstance();
                rival.newAuction(this.getClass());
            } catch (Throwable t) {
                rival = null;
            }
        }
        return rival;
    }

    @Override
    public int nextBid(int opponentsBid) {
        return calcBid(opponentsBid, isPeeking(3), isPeeking(4));
    }

    protected int calcBid(int opponentsBid, boolean isPeeking, boolean isSubPeeking) {
        if (isPeeking) {
            throw new RuntimeException();
        }

        for (int iBid = opponentsBid + 5; iBid <= 100; iBid = iBid + 5) {
            try {
                if (getRival().nextBid(iBid) < iBid + 5) {
                    return iBid;
                }
            } catch (Throwable t) {
                // noop
            }
        }
        return 0;
    }

    protected boolean isPeeking(int level) {
        final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        final StackTraceElement[] stackTraceElements = Arrays.copyOfRange(stackTrace, level, stackTrace.length);
        for (StackTraceElement ste : stackTraceElements) {
            try {
                Class<?> clazz = Class.forName(ste.getClassName());
                if (DollarBidder.class.isAssignableFrom(clazz))
                    return true;
            } catch (ClassNotFoundException e) {
                return true;
            }
        }
        return false;
    }
}