text:
Dollar Bill Auction
This is a KOTH challenge for the dollar bill auction game in game theory. In it, a dollar is being sold to the highest bidder. Bids go up in increments of 5¢, and the loser also pays their bid. The idea is that both players escalate the bidding war far beyond the value of a dollar in order to cut their losses.
Let's hope your bots are smarter than that.
You will be creating a bot to play this game by extending the net.ramenchef.dollarauction.DollarBidder class. You must implement the nextBid method that returns your bot's next bid given the other bot's previous bid. If necessary, you can also use the newAuction method to reset for each auction with the class of the opponent's bot.
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);
}

Bidding goes until one of the following happens:

nextBid throws an exception. If this happens, the bot that threw the exception pays their previous bid, and the other bot gets the dollar for free.
Either bot does not pay enough to top the previous bid. If this happens, both bots pay their bids (the loser pays their previous bid), and the winner gets a dollar.
Both bots bid over $100. If this happens, both bots pay $100, and neither bot gets the dollar.

2 auctions are held for each combination of bots. Bots are scored by the total profit they made across those auctions. The highest score wins.
Examples
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
Don't use this as a template for analytically-minded bots; use ImprovedAnalystBot instead.
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;
    }
}

Additional Rules

Standard loopholes are forbidden.
Sabotaging other bots is allowed, but attempting to alter field/method visibility will result in mysterious SecurityExceptions. An exception is causing another bot to break the 500ms limit.
Bots cannot access the runner package except to extend the DollarBidder class.
All methods should return in 500ms or less.
Bots do not need to be deterministic.
Your bid does not need to be a multiple of 5¢.
$1=100¢
Results will be posted on April 24, 2018.

Runner on GitHub
Results
View the individual rounds here.
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

Congratulations to MTargetedBot with a profit of $14.30!

This challenge is fundamentally vulnerable to One-Upping.  Since I know the class of my opponent, it is easy to pick the best strategy against it.  (Then somebody comes along, and can one-up my bot, etc)

"Bids go up in increments of 5¢". You don't have anything in your code to validate this, though.. LuckyDiceBot for example bids in increments of 2-12 randomly..

Comments are not for extended discussion; this conversation has been moved to chat.

You really should specify that bots need to be in the default package.

@NathanMerrill Put your bot in any package you like, but if you put it in the runner package, it's breaking rule 3.

@RamenChef no it's not.  If I put it in the runner package, and only access the DollarBidder class, that's still valid behavior.

@histocrat "The loser pays their previous bid". Yes; the bot would pay its last legal bid.

What happens if a bot exceeds the 500ms restriction? Does it lose like it would if it threw an error?

Also:  what if my bot causes other bots to exceed the 500ms restriction?

If your bot regularly goes beyond the 500ms restriction, it’s an invalid submission. That being said, I don’t actually expect anybody to come close to 500ms.

Preliminary results

@RamenChef We're talking about malicious code here.  What if I detect when another bot is calling me, and call Thread.sleep(1000)?

Then the counter bot would be invalid. Also, there is a counter to that.

Sorry, who is the "counter bot"?  The one sleeping?

@NathanMerrill yes.

I'm VTC this as it is unclear what sabotage is allowed and what is not.  The OP has disallowed submissions that "attacking the runner" (which is vague), and there's no clear line between malicious code that is allowed, and malicious code that isn't (How do you determine which bot caused a bot to take too long?)

"Attacking the runner" is vague, but it should be fairly obvious whether a bot is breaking it or not. As for the malicious code, it's no longer allowed as a form of sabotage. My defense of the question is this: are you really going to close the question over a nitpick?

@RamenChef Yes, I do think it should be closed:  These are solvable issues, but they aren't small;  We need challenges to be objective on this site.  Decisions about whether something is valid shouldn't just be whatever the OP decides, it needs to be objectively defined in the spec.

@NathanMerrill I feel like the issues raised - although avoidable, important and abundant - don't invalidate the challenge in its entirety. People are having fun anyway, right? Heck, even Formic Functions, which won Best of PPCG 2017, relies on sportsmanlike behavior of participants to not devolve into everlasting edit wars.

Just to be clear, I would've probably voted to close it if I paid closer attention at the start, though.

@Alion That edit war wasn't banned by the rules though.  That was a "whoever edits last wins" (the one-up scenario).  That challenge still had objective rules.

Could you have DollarBidder implement IntUnaryOperator?

@StephenLeppik ...why? If you need to use the nextBid method as a callback, you can use DollarBidder::nextBid.

Correction: use instance::nextBid.

... I'm still unclear as to where the 5¢ comes in to play...

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);
    }
}

Based on updated MBot
Uses similar method like CounterBot, but with some methods refined to harder hit some of it opponents, also should be more readable
On unknown opponent default to MBot strat

This isn't fair.

@Joshua What particularly isn't fair about this solution in your opinion?

Knowing the names of your opponents.

@Joshua half of the solutions use that information. We even wrote to author that this should be changed or One-Upping will occur, he refused to change challenge - so here it is

Now the question gets a downvote too.

@Joshua will you downvote all answers which are One-Upping - that would be fair I guess :)

Already did....

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;
        }
    }
}

Holy cow. I expected this to be simple to write, then subsequently spent 3 hours on it.
In essence, MimicBot keeps a running list of the available bots. When it goes to a new auction, it runs through the list in search of the most effective one against the current opponent. It then uses that bot as a "reference" in the auction.
For testing purposes, it would be best to use either a randomized subset of the submissions or the full set. It starts with GreedyBot, MimicBot, and one more bot that just bids 5¢.

InsiderTradingBot
In the spirit of @StephenLeppik's answer, InsiderTradingBot knows all of his opponents and understands their strategies. Your move, 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;
  }

};

Nah, insider trading would be if the RichJerk bot made a specific exception for your bot and bid $0 for it.

It's too early to be optimizing against other answers. Also, it's AnalystBot, not Analyst.

Probably there needs to be a rule "class names will be randomized".

@user202729 How about "no direct references to classes"?

@RamenChef Also fine, but then you would have to read classes' source code (and handle the md5(sha256(classname))=='1234' cases), but this can be automated.

I'd like to see this handle the MimicBot.

MirrorBot
Makes the enemy play against itself.
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);
        }
    }
}

You nuked Analyst spectacularly.

@SilvioMayolo  How?

Mirror tries to emulate Analyst playing against itself, resulting in a stack overflow.

Edit: Targeted changes in the DollarBidder class has broken this 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;
  }
}

After 1 auction, its score will be -2147483645 but the next time it will lose 5¢ or 105¢ making the score positive and very big. All other losses would then be negligible.
On the first auction, it would also make GreedyBot bet -2147483646 which isn't divisible by 5.

score is package-protected. Your bots can't access it.

@RamenChef Oops, removed the CheatingBot

There's no rule against "attacking the runner", only "accessing" it, which this doesn't do.  I recommend fixing the bug, which solves the problem:)

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;
        }
    }
}

Can't test this at the moment, so please let me know if it's broken.
Basically, pick a value for the dollar, and outbid the opponent until we exceed that value.

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;
    }
}

Very simple, it tries to determine whether an opponent would contest a minimal bid and, if not, places it.
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;
    }
}

A new, smarter version of MarginalBot that checks to see if it can make any money-making move without contest, rather than just hoping to win with the minimum.
Since its in the same family as my previous bot, but sidesteps strategies trying to beat it, I figured a new entry in the same post was the most reasonable way of presenting it.
Edit 1: Made a small change to the newAuction method to optimise against other analyser-type bots.
Edit 2: Made a change to MarginalerBot to minimise losses against sneaky or non-deterministic strategies.

Welcome to PPCG!

It’s simple, but it beats all of the other bots by a fairly large margin!

BorkBorkBot
import net.ramenchef.dollarauction.DollarBidder;

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

Gives up if it can't break even.

DeterrentBot
import net.ramenchef.dollarauction.DollarBidder;

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

Attempts to persuade any analytically-minded bots that the only winning move is not to play.

I've noticed that my somewhat cryptic comment "Joshua? Is that you?" has been deleted. So just to clarify, it was a reference to a famous quote from the film WarGames: "the only winning move is not to play". (Joshua being the nickname of the WOPR.)

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;
    }
}

It had to be done.

"Bids go up in increments of 5¢". Your bot currently isn't doing so.

@KevinCruijssen Fair enough. I also changed the upper limit so it could bid the whole $1, just in case,

LuckyDiceBot
LuckyDiceBot only trusts his dice. He rolls two dice, adds the sum to the current bidder's value, and bids that much. If it's not enough to overcome the opponent's bid, he cuts his losses and goes on his way.
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;
  }

};

How does this cut its losses or stop losses? If it always adds its dice roll to the opponents bid then you'll always bid more. The randomness might confuse a sufficiently analytical bot, I like the concept.

If the roll is 4 or less (statistically unlikely, but will eventually happen), then the bid is insufficient to beat the opponent and the auction ends.

Two things: 1. @Freiheit is right and this bot will keep bidding until it has won no matter how high. opponentsBid in nextBid(int opponentsBid) holds the total bid your opponent has bid thus far, not its next bid. A better term for the method would be raise (as the Poker term) imho. 2. Your bot doesn't bit in increments of 5 so is therefore validating one of the rules. If these problems are fixed I still like the concept though, because analytic bots won't be able to counter and so you'll most likely win quite often.

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 makes a fortune off of his illegal gambling with LuckyDiceBot. So of course when the police (DeterrentBot) arrive, he has to quickly dispose of his earnings in some way, such as bidding on the next auction.

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;
  }
}

Scenarios

If the opponent may start and bids <= 0 they lose.
If the opponent may start and bids [5,95]: bid 100 yourself. Either your opponent stops now, or will bid above 100 in total, in which case you stop bidding to let them have the win and break even yourself.
If the opponent may start and bids >= 100: bid 0 yourself to lose but break even.
If you may start: bid 100 right away. Either your opponent stops now, or will bid above 100, in which case you stop bidding to let them have the win and break even yourself.

Wow that is a bug. It said I was commenting on the question, but it ended up here. Gotta find a way to reproduce it

@RamenChef Typo.. But I've modified the entire bot. It had some bugs anyway..

This can absolutely lose money.  If you bid 100, then your opponent bids 105, you end up losing 100, and they only lose 5.

@Mnemonic Ah of course.. Hadn't thought about that part.. Hmm.. that makes things more interesting but also harder. Will edit the description for now, but leave the bot as is.

I think you mean "lose" not "loose". Lose is the opposite of win. Loose is the opposite of tight.

@Kat Thanks. English is not my native language, although I'm not too bad in it if I saw so myself. "Loose" was something I always did like this as opposite of "win", so thanks for the correction. Will try to remember it from now on. :)

@KevinCruijssen it's an extremely common spelling mistake among native speakers, so don't feel too bad. =] Your English is indeed quite good.

Non-competing: 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;
        }
    }
}

This is not intended as a true submission, but rather as some boilerplate for others to use to deter pet-keeping bots like MirrorBot and MimicBot.
Since it's the default constructor, there's no need to call it in your subclass. It implements an isPeeking method to determine if another bot is snooping.

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;
        }
    }
}

Can't test this at the moment, so please let me know if it's broken.
Each round, the value of the dollar goes up.

This would be excellent against MirrorBot, MarginalerBot, and probably also MimicBot.

@StephenLeppik That's what I was thinking when I made it. Still plenty of weaknesses, though.

+1, I like the idea. Hmm, is it intended that your bot bids 0 and breaks even if it starts a round (when opponentsBid is still 0)?

@KevinCruijssen Yes. That can only happen against the very first opponent. Any of the bots that copy it will start at 0, so this won't waste more than 5c on them.

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;
        }
    }
}

cobbled together from parts of other bots. this one plays by trying to be AnalystBot, and if unsuccessful, becomes BorkBorkBot.
I don't think this one will do that well.

Watch out for the AnalystKiller.

@RamenChef AFAIK the analyst killer just throws an exception if it sees itself being analyzed. I can catch that

You probably should catch it.

@RamenChef No idea if that will work, I can't Java

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;
  }
}

Counters:

DarthVader counters itself by causing a SecurityException before the bidding starts, but I'll bid 5 just in case.
AnalystBot and AnalystOptimizer will both look at my answer when I bid 95, in which case I'll show I bid 100 so it will bid 95 itself. I will bid 5 however if I start (or 100 if they've started), so they lose 95 cents and I either win the 1 USD bill by only bidding 5 cents, or by breaking even.
MirrorBot will bid what I would bid against it. So I'll just bid 5, and whoever begins wins 95 cents, and the other loses 5 cents.
MarginalBot will bid 5 if I would bid less than 10 (or what it starts), otherwise it will bid 0. So if I just bid 5 when I start, or 10 when it starts, I win either 95 or 90 cents, and they lose 5 cents.
GreedyBot always bids 5 more than me, so just bid 0 to break even and let them have the win
OnlyWinningMove and AnalystKiller both always bids 0, so just bid 5 to win
TargetValueBot will bid in the range [100,200], so bid 5 more every time until they're at 190, in which case we raise to 200 to break even by winning the dollar (and let them lose 190 or 195 depending on who started)
BorkBorkBot will bid in the range [5,95], so bid 5 more every time as well. As soon as they bid either 85 or 90 (depending on who started), bid 95 yourself. They'll lose 85 or 90 cents, and you win the 1 USD bill for a 5 cents profit.
DeterrentBot will bid 5 if they start or 100 if we start, so just bid 105 so they counter with 100, causing them to lose 100 and us to lose just 5 cents by winning the 1 USD bill.
BreakEvenAsap will bid 100 right away. So if they've started with their bid of 100, counter with 105 to win 95 cents and let them lose 100. If we may start just bid 100 so we both break even.
RichJerk will bid 10,001 right away, so just bid 0 to break even and let them lose 9,901.
DeterredBot doesn't know me and will therefore bid 0, so just bid 5 to win.
LuckyDiceBot keeps on bidding till it wins. So if we started, bid 5 in the hope they bid as high as possible to win the dollar. If they've started just bid 0 to let them have the win and break even yourself.
RandBot will bid random in the range [5,100], so just bid 5 more until it stops, in which case you've won 95 cents and they've lost 0-100.
UpTo200 will (as the name states) bid up to 200. So just bid 5 higher until they stop. We'll win the 1 USD bill and take a total loss of 105 cents, they however lose 200 cents.
InsiderTradingBot doesn't know me, so just bid 5 cents to win
MimicBot was the hardest. Just bid 10 to either start with or counter their first bid of 5. If they try to access me I will throw a RuntimeException (which they will catch in which case it would act as if I had bid 100 instead - although it will break the inner while-loop). Based on the enemies it has in it's HashSet a different thing happens. I'll have to revisit and look more closely to see if there is an actual counter.
RiskRewardBot doesn't know me so will just bid 5, in which case I will bid 5 to win.
MarginalerBot will bit up to 100 depending on what I would bid. If I may start, I will bid 90, then it will bid 95, then I will bid 100 so it will bid 0 and lose 95 cents, while I win the 1 USD bill and break even. If it may start instead, it sees I would bid 90 against it, so it bids 90 itself, then I will bid 95 so it will bid 0 and lose 90 cents, while I win the 1 USD bill with a 5 cent profit.
BuzzardBot will analyze all my counters in the range [0,100). If I bid 100 right away it use oppFlag = 0 and the complete 100-sized array will contain 100x the value 100. In the switch case 0, the loop will be in the range [0,100) again, and since i + 5 will at most be 104, the if bids[i] < i + 5 won't ever be true, so the bid it does remains 0.
ImprovedAnalystBot will always have this.enemy = null because his opponent is CounterBot, not itself. So it will always bid 0, which I just counter with a bid of 5.
InflationBot will bid 0 to break even when it starts, otherwise it will keep bidding 5. So just bid 0 ourselves to break even right away and let them have the win.
ScoreOverflowBot will either bid near Integer.MAX_VALUE if they may start, otherwise they'll bid 105. So if they've bid 105 just bid 110 ourselves (they'll lose 105, we'll lose 10), otherwise just bid 0 to let them have the win.
MBot is the same as MarginalerBot, but with added protection against 'peeking' opponents. Since I don't 'peek', it's basically the same as MarginalerBot.
SecretBot will have his isPeeking() method return false, so if it may start or if I bid 5, it will bid 5 or 10 respectively. Otherwise it will bid 0. So whether I start or not, opponentsBid + 5 would cause me to win either way, either with my 10 cents or 15 cents bid, causing them to loose either 5 or 10 cents.
BluffBot will look at what I would bid when his bid is 95, and if this is larger than or equal to 100 it will bid 0 to break even, otherwise it will bid opponentsBid + 5. So I'll just bid opponentsBid + 5. It'll break even regardless of who starts, and I win either 100 or 95 cents depending on whether I have started or not.
StackTraceObfuscaterBot will act the same as MarginalerBot.
EvilBot will always bid 5, so just bid opponentsBid + 5. Either way they'll loose those 5 cents, and we'll win the 1 USD bid (either with a 5 cents bid if we've start, or 10 cents bid if they've started).
MSlowBot is the same as MBot and therefore also MarginalerBot.

Let me know if you see any typos or flaws in my counters.

MirrorBot calls newAuction with your own class, so that's a problem. Also, glad to know the 3 hours I spent on MimicBot weren't in vain.

@StephenLeppik Removed the code in the newAuction because it would fail more often than not.. I can't counter MirrorBot nor can it counter me. Whoever begins of the two wins 95 cents and the other loses 5 cents.

What you have right now is a pretty good counter to MirrorBot: throw if you encounter yourself.

Holy ternary chaining, Batman!

Also, when playing BorkBorkBot, shouldn't you raise to 95 when they hit 85? Otherwise you're both bidding 95 if they start.

@Skyler Thanks for noticing, fixed! As for the ternary, it's shorter and still pretty readable than all those else-ifs I had before. ;)

Have you considered using my AbstractAnalystCounterBot?

Code review - RichJerk and GreedyBot are covered by the default case.  I also think theres some way to rejigger a few of these cases to just bid 5 more.

@Qaghan Thanks, should be fixed now.

@Freiheit I know. I just used an additional case to return 0 in case I wanted to change the default for whatever reason. But I've put them under the default now (by commenting them out). And I know I can golf everything by quite a bit, but this isn't about making the shortest code. I just made it a ternary to make it a bit more compact, but that's about it. Will just leave it like this for now.

For some of these counters it seems like you're assuming you'll get the opponent's losses added to your winnings, which isn't the case. For example, against DeterrentBot, you won't win 95 cents by bidding 105 over its 100, you'll lose 5 cents (and DeterrentBot will lose 100 cents). I guess if you're thinking in zero sum terms that's like winning 95 cents, but it won't help with your overall score.

@histocrat Ah, that was just a mistake in the explanation of the DeterrentBot. You're completely right. They loose 100, I loose 5. Fixed the explanation. If you see any other mistakes let me know. I know I won't get the amount my opponents bid, so if any of the other incorrectly reflects that it would be a mistake on my part as well..

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;
        }
    }
}

Can't test this at the moment, so please let me know if it's broken.
The goal is to get the highest total score, so don't worry about beating anyone.  Just take the easy wins, and don't waste money on possible losses.

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;
    }
}

Tries to evaluate the opponent it's faced with, and make sure to not bite off more than it can chew.

Welcome to PPCG!

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;
}

}

A spy you know of is more valuable than no spy at all...
If someone else tries to call the getBid method, BluffBot responds with $100 to trick them into either quitting or betting really high.
Otherwise, see if it's possible to win for under $1, and just don't bid if it's not.

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;
    }

}

Throws an Error instead of an Exception to confound analysts.

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;
  }
}

Darth Vader
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;
}
}

This one tries to force the opponent's bot to overpay by setting the integer cache to the value over the $100 limit.

The security manager would stop this.

And this wouldn't work anyway since nowhere in the runner does it box its integers.

Even if this wouldn't be stopped, this is a jerk move, although valid. "Sabotaging other bots is allowed, but attempting to alter field/method visibility will result in mysterious SecurityExceptions."

@StephenLeppik The point of this is to break things like return opponentsBid <= 195 ? opponentsBid + 5  : 0 and make it return opponentsBid <= 100001 ? opponentsBid + 100001 : 100001.

@NoOneIsHere That also doesn't box any integers and so wouldn't be affected.

@StephenLeppik oh, I see. I don't use Java.

Fails to compile because of unchecked exceptions.

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;
    }

}

This bot makes minimal attempts to win by bidding 5 or 10. He also checks the stack trace to see if he was called by another Bot and then lies to them about what bids he'll make.

Mind if I port isPeeking into AbstractAnalystCounterBot?

@StephenLeppik, well, I stole it from MBot...

Well, MBot probably stole it from me…

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;
    }
}

This bot laughs at attempts to detect reflection via the stack trace. The closest thing they see to a DollarBidder is some lambda class it created. Clearly not another bot trying to reflect them. Little do they know that that lambda class is actually working for a DollarBidder. Beyond that, he acts like MarginalerBot.

Note that I've since updated my stack trace check to handle this.

Non-competing: MSlowBot
import net.ramenchef.dollarauction.DollarBidder;

import java.util.Arrays;

public class MSlowBot extends DollarBidder {
    private DollarBidder rival;

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

    @Override
    public int nextBid(int opponentsBid) {
        noPeeking();

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

    private void noPeeking() {
        final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : Arrays.copyOfRange(stackTrace, 3, stackTrace.length)) {
            try {
                Class<?> clazz = Class.forName(ste.getClassName());
                if (DollarBidder.class.isAssignableFrom(clazz))
                    Thread.sleep(1000);
            } catch (ClassNotFoundException | InterruptedException e) {
                throw new RuntimeException(":(");
            }
        }
    }
}

Same logic as MBot, just use timeout instead of Exception when fighting against enemy. So far no one is defending agains timeout so should be effective

The stated rules forbid deliberately causing another bot to timeout.

@WinstonEwert can you quote? I can't find rule disallowing this

"Sabotaging other bots is allowed, but attempting to alter field/method visibility will result in mysterious SecurityExceptions. An exception is causing another bot to break the 500ms limit." Also, I'm defending against timeout.

@RamenChef but this don't alter visibility of other elements. I'm not sure if I understand you correctly. Is provoking timeout allowed?

"An exception is causing another bot to break the 500ms limit." Specifically, this is an exception to the rule about sabotage.

@RamenChef Ok I checked rules again, and yes rule about that was added recently :)

One 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;
    }
}

Bids 6 more than the last bid, just because he can.

He can't bid 6 since all bids must be multiples of 5...

@Neil it's probably a typo...

@Neil the rules specifically state: "Your bid does not need to be a multiple of 5¢"

@MegaTom Huh, well that was added since I last read the rules...

@Neil It was part of the original rules, but I added it there because it wasn't very obvious.

ImprovedAnalystBot (non-competing)
A lot of people seem to be using the AnalystBot code as a template, even though it's deliberately bad code. So I'm making a better template.
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;
        }
    }
}

Why not just edit your challenge?

@NathanMerrill How would I edit it?

By clicking the edit button, and replacing AnalystBot with this code?

@NathanMerrill AnalystBot is deliberately bad code so that it can demonstrate the AnalystKiller sabotaging it.

The AnalystKiller still works with the improved one :)  The issue with making it a post is that the challenge is far more visible than an answer.

This would catch the exception thrown by AnalystKiller.

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;
    }
}

Slightly refined MarginalerBot

be unkind to those who wan't to check you
allow paying 100 to get 100 and break even case, just to deny others easy money

You can't declare nextBid to throw ClassCastException.

@RamenChef ok, swapped it to RuntimeException which don't require declaration :)

Your code for stack trace checking looks suspiciously similar to mine.

@StephenLeppik probably it's copy of it

@mleko why though? The class it's copied from is an abstract superclass that's free to use.

@StephenLeppik well the original ripped code was a little bit different than what I needed, later we converged again

@mleko at the very least, you're missing an update to counter the StackTraceObfuscatorBot.

TimeRandBot
import net.ramenchef.dollarauction.DollarBidder;

public class TimeRandBot extends DollarBidder {

    @Override
    public int nextBid(int opponentsBid) {
        return (int) (System.currentTimeMillis() % 21 * 5);
    }
}

Bids from 0¢ up to 100¢ inclusive in increments of 5¢.


text:
Recovering Range Parameters
Description
You are given the results of a range function where every element has been rounded down to the nearest whole number. Your goal is to recover the original list.
For example, the following function (in Python3) will produce an input for your program:
from numpy import arange, floor
def floored_range(A, B, C):
    return list(floor(arange(A, B, C)))

The output of your program should be a valid guess of the original data. Here, valid guess means that it must exactly match the input when floored and it must be a possible output of a range function (ie, when graphed it must form a perfectly straight line).
Examples
Input: [1,2,3,4]
Output: [1,2,3,4]

Input: [1,2,3,4]
Output: [1.9,2.7,3.5,4.3]

Input: [1,2,3,4,5,5]
Output: [1.9,2.7,3.5,4.3,5.1,5.9]

Input: [1,1,2,2,3,3,4,4]
Output: [1,1.5,2,2.5,3,3.5,4,4.5]

Input: [1,1,2,3,3,4]
Output: [1,1.7,2.4,3.1,3.8,4.5]

Input: [56, 54, 52, 50, 48, 45, 43, 41, 39, 37, 35, 32, 30, 28, 26, 24, 22, 19, 17, 15, 13, 11]
Output: [56.7  , 54.541, 52.382, 50.223, 48.064, 45.905, 43.746, 41.587,
   39.428, 37.269, 35.11 , 32.951, 30.792, 28.633, 26.474, 24.315,
   22.156, 19.997, 17.838, 15.679, 13.52 , 11.361]

You should require at least one of the output value to be decimal, otherwise we could return the input everytime.

@Therandomguy when graphed it must form a perfectly straight line

Oooooh. i didn't see this. It should spice things up.

it's always guaranteed that the input is valid? e.g. 1,1,2,2,3,3,10,99

@Rod you can assume that you will always get a valid input

Will the range before rounding down always be non-decreasing? Or can it be something like [1, 0, -1]? Also, will it always start at 1?

the difference between the elements will always be <=1?

Using the formula in the question, A, B, C can be any three floats. The input floored range can, for example, start at 56.7, end at 10.2 and have a step size of -2.159. The only thing that matters is that the points you output, when floored, exactly match the input. I've added an example showing that.

This can be done in linear time.

@KyleGullion I took the liberty to modify the second test case, feel free to rollback if you disagree with it

I can see some numerical issues here.

@Rod As I see it, the point of the original second test case was to illustrate that several outputs are possible for the same input

@LuisMendo fair enough

@Rod Just keep both.

It's probably too late to add as a requirement, but I'd love to see something that can handle a dataset like this. I didn't consider the random guessing approach when coming up with the problem. C'est la vie...

Octave, 82 bytes
function y=f(x)
while any(floor(y=linspace(x(1)+rand,x(end)+rand,numel(x)))-x),end

Running time is non-deterministic, but the code ends in finite time with probability 1.
Try it online!
Explanation
The code defines a function of x that outputs y. The function consists of a while loop.
In each iteration, the right amount (numel(x)) of linearly spaced values are generated (linspace), starting at x(1)+rand and ending at x(end)+rand. These two calls to the rand function give random offsets between 0 and 1, which are applied to the initial and final values of x.
The loop is repeated for as long as any of the floored results differs (-)  from the corresponding entry in x.

78 bytes using a!=b instead of any(a-b)

@ovs Unfortunately that doesn't work, because it stops as soon as some output entry equals that in the input, not when all do. See second entry of the second output in your link

(because it's provable that the probability for a randomly chosen line to be valid is nonzero)

Python 3, 189 bytes
def f(l):
 R=range(len(l));e=1-1e-9
 for j in R:
  for I in range(j*4):
   i=I//4;L=[((l[i]+I//2%2*e)*(x-j)-(l[j]+I%2*e)*(x-i))/(i-j)for x in R]
   if[x//1 for x in L]==l:return L
 return l

Try it online!
Cubic time.
Has some numerical issues.

R, 86 bytes
function(n){while(any(n-(x=seq(n[1]+runif(1),tail(n,1)+runif(1),l=sum(n|1)))%/%1))0;x}

Try it online!
R port of Luis Mendo's answer; it does issue a number of warnings because of any coercing to logical but these can be ignored.

Python 3, 168 bytes
def f(l):r=range(len(l));g=lambda n:[(l[b]+n-l[a])/(b-a)for a in r for b in r if b>a]or[0];s=(max(g(-1))+min(g(1)))/2;m=min(a*s-l[a]for a in r);return[a*s-m for a in r]

Try it online! Explanation: g calculates the limiting values for C that lie just outside the range for A and B to exist. The average is then taken to give a usable value for C, and then the lowest possible range is then generated.

JavaScript (Node.js), 94 bytes, assuming input length > 1
f=x=>(t=x.map(_=>a+=b,b=x[1]+(c=Math.random)(a=x[0]+c())-a,a-=b)).map(Math.floor)+''==x?t:f(x)

Try it online!
97 bytes
f=x=>(t=x.map(_=>a+=b,b=x[1]+(c=Math.random)(a=x[0]+c())-a||0,a-=b)).map(Math.floor)+''==x?t:f(x)

Fails for [1].

Jelly, 31 bytes
ṾṚ”.;V×LḶ$}+©1ị$}IEȧḞ⁼¥ʋ
0ç1#®ḷ

Try it online!
Warning: Floating-point inaccuracies.

Doesn't terminate for [1,2,3,4,5,5] in 30 seconds on TIO. Some explanation please?

@user202729 Most probably floating-point inaccuracies. I'll check it out.

Python 2, 212 bytes
def f(l):
 C=[(0,1.,0,1.)]
 for a,A,b,B in C:
  x,y=(A+a)/2,(B+b)/2;r=[l[0]+x+i*(l[-1]+y-l[0]-x)/(~-len(l)or 1)for i in range(len(l))];C+=[(x,A,y,B),(a,x,y,B),(x,A,b,y),(a,x,b,y)]
  if[n//1for n in r]==l:return r

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Four Spiraling Axes
Take the numbers 0, 1, 2, 3, 4, ... and arrange them in a clockwise spiral, starting downward, writing each digit in its own separate square.
Then, given one of four distinct and consistent ASCII characters (your choice) representing an axis, and an input integer n, output the first n terms of the sequence described by selecting squares along the corresponding axis.
For example, below is the arranged spiral up to partway through 29. Suppose we use u / d / l / r for our four characters, representing up / down / left / right. Then, given u as input, we output 0, 5, 1, 4 ... (the positive y-axis) up to the nth term. If we were instead given l as input, then it would be 0, 3, 1, 1 ... up to the nth term.
  2---3---2---4---2---5---2
  |                       |
  2   1---3---1---4---1   6
  |   |               |   |
  2   2   4---5---6   5   2
  |   |   |       |   |   |
  1   1   3   0   7   1   7
  |   |   |   |   |   |   |
  2   1   2---1   8   6   2
  |   |           |   |   |
  0   1---0---1---9   1   8
  |                   |   |
  2---9---1---8---1---7   2

These are sequences on OEIS:

http://oeis.org/A033953 for the positive x-axis
http://oeis.org/A033988 for the positive y-axis
http://oeis.org/A033989 for the negative x-axis
http://oeis.org/A033990 for the negative y-axis

Examples
d 19
[0, 1, 1, 8, 3, 7, 6, 2, 1, 5, 1, 1, 6, 2, 2, 1, 3, 4, 0]

r 72
[0, 7, 1, 7, 4, 2, 8, 1, 1, 3, 1, 2, 0, 2, 3, 1, 3, 4, 6, 5, 5, 5, 7, 7, 8, 8, 9, 6, 8, 1, 1, 1, 2, 3, 1, 8, 0, 6, 1, 7, 0, 9, 2, 8, 4, 3, 2, 1, 1, 7, 2, 6, 2, 1, 3, 3, 5, 5, 3, 2, 2, 0, 4, 3, 2, 5, 4, 6, 5, 0, 5, 1]

u 1
[0]

Rules

If applicable, you can assume that the input/output will fit in your language's native Integer type.
If you're using integers to represent the four axes, you can use negative integers without breaking the rules.
The input and output can be given by any convenient method.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Can we take negative integers for a couple directions?

@mbomb007 Sure, that would be OK.

Doesn't seem very practical, but can we return an integer that has the required digits except the leading zero (which would be implied anyway)?

@AdmBorkBork Basically I don't have such a solution in mind, just thought to ask. :)

A challenge is judged by the output. So if the zero isn't included, I'd think that would be wrong, because you'd count it wrong if the zero is excluded for string output. Python can output integers with leading zeros, so why not other languages.

@mbomb007 That's a good point. I'll reverse that ruling.

@EriktheOutgolfer Ruling reversed, see mbomb's point.

@Kitana Just figured out that the spiral is infinite and not limited to n numbers with wraparound.

Python 2, 94 89 84 83 74 72 70 bytes
I used WolframAlpha and determined that an upper bound of 5n > 4n2+3n seems to be enough. It can be changed to 9n at no cost. For trying larger inputs, use 9*n*n instead of 5**n to avoid running out of memory.
lambda d,n:["".join(map(str,range(5**n)))[x*(4*x+d)]for x in range(n)]

Try it online!
The inputs for directions are:

3: right
-3: down
-1: left
1: up

Saved 14 bytes thanks to Rod
Saved 2 bytes thanks to Jonathan Allan

MATL, 32 bytes
tE1YLtn:qVXzw)3Lt3$)iX!w:qyfYm+)

Input is n, a, where a represents the axis as follows:

0: left;
1: up;
2: right;
3: down.

Output is a string.
Try it online! Or verify all test cases.

will work for considerable n (like +1000)
JavaScript (Node.js), 104 bytes
f=(d,n)=>--n?[...f(d,n),C(n*(4*n+d))]:[0]
C=(n,N=i=0)=>n>N?C(n-N,(p=10**i)*9*++i):+((p+--n/i|0)+"")[n%i]

Try it online!
Explanation

3: right
-3: down (-3 is legit according to comments)
-1: left
1: up
(like @mbomb007)

C- nth digit of Champernowne's constant
________________________________________________________
Less efficient method (wont work for 1000+)
JavaScript (Node.js), 81 bytes
f=(d,n)=>eval(`for(r=[],s=i=I="";I<n;)(s+=i++)[u=I*(4*I+d)]&&r.push(s[I++,u]),r`)

Try it online!

Jelly,  19  18 bytes
Uses the 5n trick from mbomb007's Python answer
4,0jḅɗ@€ị5*D€FʋṖ0;

A dyadic link taking n on the left and d and integer from: [-3,-1,1,3]:[v,<,^,>]
Try it online!
A 20 byte alternative that is both much faster and does not segfault for such small n is:
²×5D€ƲFị@4,0jḅɗ@€Ṗ0;

Try it online!
How?
4,0jḅɗ@€ị5*D€FʋṖ0; - Link: integer, n; integer, d
     ɗ@€           - last three links as a dyad with sw@pped arguments for €ach (of implicit range [1,n])
4,0                -   literal list [4,0]
   j               -   join with d = [4,d,0]
    ḅ              -   convert from base n = 4*n^2+d*n+0
        ị          - index into...
              ʋ    - last four links as a monad:
         5         -   five
          *        -   exponentiate = 5^n
           D€      -   decimal list of each (in implicit range [1,5^n])
            F      -   flatten into a single list of the digits
               Ṗ   - pop (drop the final element)
                0; - prepend a zero

Stax, 13 bytes
â╞ê←τ"(]]⌐┘?N

Run and debug it
It takes input with the direction, followed by the count.  Right, up, left, and down are 1, 3, 5, and 7 respectively.  It takes a full minute to run the three provided test cases.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Isogram checker
Challenge :
Given a word, check whether or not it is an isogram.

What :
An isogram is a word consisting only of letters with no duplicates (case insensitive). The empty string is an isogram.

Examples :
"Dermatoglyphics"     ---> true
"ab"                  ---> true
"aba"                 ---> false
"moOse"               ---> false
"abc1"                ---> false
""                    ---> true

Input :
You may accept input in any reasonable format
The input will only contain letters and/or numbers, no spaces ([a-zA-Z0-9])

Output :

true or any truthy value if the input is an isogram
false or any falsy value otherwise

This is code-golf so shortest code in bytes in each language wins.

Suggested test case: sad2

Your definition of isogram includes two different contradictory statements.  Which is it?

@WhatWizard Neither. Wikipedia says nothing about digits.

@Adám Then why include the definition? I also don't see any other definition of the term used so what are we supposed to do?

Suggested rewording of entire post: Given a word consisting of ASCII letters and digits ([0-9A-Za-z]+), determine whether it has any digits or case-insensitive duplicates.

@Adám : Hi. I am going to update the post. Wait one second. Thanks

I would recommend that you start using the sandbox so that these issues can be caught prior to posting the challenge.

@MuhammadSalman This is very sloppy, please remove ". Any" from the end of you quote and give some more examples (sad2das would fail even without the 2 so it doesn't show anything).

The "What" and the "Notes" seem to contradict one another: "Implement a function that determines whether a string that contains only letters is an isogram" (emphasis added) and "There may be numbers and those will and must return false" say opposite things. I have voted to close as unclear for the moment, but will happily retract it once that is cleared up!

Do output truthy and falsy values need to be consistent, or can they be different depending on the input?

@LuisMendo : I would rather prefer if they were consistent , though second one also works.

@Giuseppe : I updated both. Take a look

@AsoneTuhid : updated. Thanks , is this better?

@MuhammadSalman You should probably decide on a single way to handle digits, I suggest "return false if the word contains any digits" as that's what most of the answers assume. Please use the sandbox next time.

@AsoneTuhid : Oh well. I guess that works too. Updated

@AsoneTuhid : Added

@MuhammadSalman Can you add a test for mixed case in there too, where the repeated letters have different case, e.g. "Aab" - my initial solutions didn't cope with this and returned true instead of false.

Trivia: The Google Universal Analytics script contains a minified function whose seven parameters are named i, s, o, g, r, a, and m.

@Neil : I am quite well aware of that and its purpose as well.

@Neil : Although thanks

Sorry, I had no idea until I stumbled across it earlier today.

Python 2/3, 36 52 48 bytes
lambda s:len(s)==len({*s.lower()}-{*str(56**7)})

Try it online!
I take advantage of the fact that set contains only unique elements.  By invoking the __len__ method of each, I can determine whether s also contains only unique elements (ignoring case).
EDIT: Updated to satisfy the previously-overlooked requirement to return False for numeric inputs. The set of all digits is encoded as set(str(56**7)).
EDIT 2: Following this user suggestion, I now take advantage of unpacking the arguments to set comprehension.  This formally breaks compatibility with Python 2.

welcome to PPCG! This also is supposed to return false when s contains a digit character.

is using \56**7`(as in the other python answer) instead ofstr()` shorter? I'm not familiar with python but that seems to be the main difference between your two answers.

@Giuseppe python3 don't have \``, a python2-only version would save 4 bytes (3 on this + 1 on division instead equals)

@Rod exactly right.  Funnily enough, the 56**7 was inspired by your own encoding of the digits 0-9 below, but saves on yours by 1 byte.

Perhaps you can add a Python 2 version? 46 Bytes: lambda s:len(s)==len(set(s.lower())-{\56**7`})`

@SunnyPatel That does not actually work, unfortunately; you actually need to call set on \56**7``.

Well I be damned. I didn't check the test case with a number. xD

Saves one byte: You can use 7/17 (0.4117647058823529) instead of 56**7. It also includes a ., but since you're taking the difference from the input it doesn't matter since the input never contains a ..

05AB1E, 5 bytes
lDáÙQ

Try it online!
Explanation
l        # convert input to lower-case
 D       # duplicate
  á      # keep only letters
   Ù      # remove duplicates
    Q     # compare for equality

R, 41 bytes
!grepl("(.).*\\1|\\d",tolower(scan(,"")))

Try it online!
Regex approach. !grepl(regex,scan(,""),F) didn't work so I guess capturing doesn't match case-insensitively in R? I'm bad at regex in general, though, so I won't be surprised if I'm just doing it wrong...
R, 58 bytes
!anyDuplicated(c(el(strsplit(tolower(scan(,"")),"")),0:9))

Try it online!
Appends the digits 0:9 to the (lowercased) list of characters and tests if there are any duplicates.

Ruby, 25 23 21 bytes
-2 bytes on both thanks to Giuseppe
->s{/(.).*\1|\d/i!~s}

Try it online!

-2 bytes thanks to Kirill L.
Ruby -n, 21 19 18 16 bytes
p !/(.).*\1|\d/i

Try it online!

@Giuseppe I didn't think that would work, thanks

I think, in the second version, you don't even need $_ - just throwing in a regex without anything else implicitly matches it against $_: 16 bytes

@KirillL. thanks, I never saw !/.../ before, can't even find it on ruby-doc.org

Not surprising, I also learned about it here after getting advice from some Perl guy :)

@KirillL. not surprising either, ruby weirdness is generally inherited from perl

Brachylog, 4 bytes
ḷo⊆Ạ

Try it online!
The predicate will succeed if the input is an isogram and fail if it is not, outputting the lowercase Latin alphabet if it does succeed. Since Brachylog's ⊆ built-in predicate doesn't exactly match the ordinary relationship between a subset and superset, I had to spend a byte on sorting the lowercased input, but saved a byte on not having to explicitly check for duplicates in it. (If it didn't need to fail with numbers, we could just use ḷ≠.)

JavaScript (Node.js), 29 25 bytes
s=>!/(.).*\1|\d/i.test(s)

Try it online!
Thanks for the update on answer to @BMO , @l4m2 , @KevinCruijssen
-4 bytes thanks to @KevinCruijssen

s=>!/(.).*\1|[^a-z]/i.test(s)?

@KevinCruijssen : I didn't see the updated version

I'm pretty sure [^a-z] can be replaced with \d

@KevinCruijssen : Thanks. updated

Husk, 6 bytes
§=f√ü_

Try it online!
Explanation
§=f√ü_  -- takes a string as argument, eg: "sAad2"
§       -- fork the argument..
  f√    -- | filter out non-letters: "sad"
    ü_  -- | deduplicate by lower-case: "sAd2"
 =      -- ..and compare: 0

Japt 2.0, 12 11 bytes
-1 byte thanks to Nit
v
f\l â eUq

Test it online!

Uh, why did you change the version to a longer one? Also, I think the last version of Japt is 1.4.4...

@EriktheOutgolfer The original didn't account for numbers automatically returning false.

Ah, so you used an alpha version because it's actually shorter.

@EriktheOutgolfer Right. The regex would've cost +2 in vanilla Japt. https://ethproductions.github.io/japt/?v=1.4.5&code=diBmIiVsIiDiIMqlVWw=&input=ImExIg==

Matched with vanilla Japt, not using regex makes it equal length: https://codegolf.stackexchange.com/a/162672/16484

11 bytes: https://ethproductions.github.io/japt/?v=2.0a0&code=dgpmXGwg4iBlVXE=&input=InNhZDIi

@Nit Thanks! Good use of e

Retina, 16 bytes
Ci`(.).*\1|\d
^0

Returns 1 as Truthy and 0 as Falsey values.
Thanks @Neil for discovering and fixing a bug in my initial code.
Try it online.
Explanation:
C             Check if the input matches part of the following regex:
 i`            Case insensitivity enabled
               Check if part of the input matches either:
  (.)           A character `C`
     .*         followed by zero or more characters
       \1       followed by the same character `C` again
         |     Or
          \d    A digit
^0             Invert Truthy/Falsey, basically replacing every 0 with a 1,
               and every other value with a 1

Why is yours opposite ?

@MuhammadSalman Two reasons: reversing the matches would cost more bytes. And I'm not too skilled with Retina so I'm not sure how to reverse the matches to begin with.. xD

reason 1). Ah ok. reason 2). LOL

Japt, 12 bytes
;v
oC ¬â eUq
Explanation:
;v
;         // Set alternative default vars, where C is the lowercase alphabet
 v        // Make the implicit input lowercase and reassign it
oC ¬â eUq
oC        // Remove all items from the input that are not in the alphabet
   ¬â     // Split into chars and select unique array items
      eUq // Check if the result is equal to the input split into chars

Try it here.

MATL, 9 bytes
kt2Y2X&X=

Try it online!
k   % Lowercase implicit input
t   % Duplicate that
2Y2 % Push lowercase alphabet
X&  % Intersection of alphabet and duplicate lowercase input
X=  % Check for exact equality.

Python 3, 46 bytes
lambda s:s.isalpha()*len(s)==len({*s.lower()})

Try it online!

PowerShell, 91 bytes
param($b)($a=[char[]]$b.ToUpper()|group|sort c*)[0].Count-eq$a[-1].count-and$b-notmatch'\d'

Try it online!
Naive solution, but I can't come up with a better algorithm. Takes input $b, converts it ToUppercase, casts it as a char-array. Pipes that array into Group-Object which constructs a object that has name/count pairs for each input letter. We then sort that based on the count and take the 0th one thereof. We check that its .Count is -equal to the .Count of the last [-1] pair. If so, then the counts are all equal, otherwise we have a different amount of letters.
We then -and that with checking whether the input -notmatches against \d to rule out any digits in the input. That Boolean result is left on the pipeline and output is implicit.

Jelly, 8 bytes
ŒufØA⁼QƲ

Try it online!

Python 2, 57 56 bytes
x=input().lower()
print len(set(x)-set(`763**4`))/len(x)

Try it online!
First it turn then input into a set, removing the duplicates, then remove the digits (encoded in `763**4`), then check if the length is the same as the original input

Java 8, 61 39 bytes
s->!s.matches("(?i).*((.).*\\2|\\d).*")

Explanation:
Try it online.
s->  // Method with String parameter and boolean return-type
  !s.matches("(?i).*((.).*\\2|\\d).*")
     //  Return whether the input does not match the regex

Regex explanation:
String#matches implicitly adds ^...$.
^(?i).*((.).*\2|\d).*$
 (?i)                      Enable case insensitivity
^    .*                    Zero or more leading characters
       (       |  )        Followed by either:
        (.)                 Any character `C`
           .*               with zero or more characters in between
             \2             followed by that same character `C` again
               |           Or:
                \d          Any digit
                   .*$     Followed by zero or more trailing characters

Visual Basic for Applications (32 bit), 102 bytes
s=LCase(InputBox(u)):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^Instr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0

Used the fact that in VBA 0^x yields 1 if x is zero and 0 otherwise. Run in immediate (debug) window.
Edit: as pointed out by Taylor in the comments this only works in 32 bit installs of MS Office.

If you restrict your language to Excel VBA, then you can swap this over to s=LCase([A1]):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^InStr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0 for 95 bytes by taking input from [A1]. Also, it is worth noting that because Exponentiation in VBA is weird that this solution is restricted to 32 bit installs of office.

Also, you can make your answer look better and more readable by using proper capitalization (see above) and adding a <!-- language-all: lang-vb --> flag to your answer to add syntax highlighting

@TaylorScott thanks! Added syntax highlighting and noted de 32 bit restriction. About the Excel input, I'd rather keep the solution application-invariant whenever possible.

APL (Dyalog Unicode), 12 bytes
Anonymous tacit function.
(∪≡~∘⎕D)819⌶

Try it online!
819⌶ lowercase
(…) apply the following tacit function on that:
 ~∘⎕D remove Digits from the argument
 ∪≡ are the unique elements of the argument identical to that?

Perl 6, 22 bytes
{!(.uc~~/(.).*$0|\d/)}

Try it online!
No matches for some character then later the same character. Implicit function as a code block, match implicitly on $_, invert book with !. Added |\d (ta Adam) but also needed .uc~~, which needed parentheses...
Alternative with Bags, 23 bytes
{.uc.ords.Bag⊆65..97}

Try it online!
This one normalises case then makes a bag (set with incidence counts). Subset or equal only true if all members are members of the comparison Bag, and all incidence counts are less than or equal to those in the comparison Bag. So any repeats or digits would make the comparison false.

Fails on abc1.

Ah, wrote this answer before the numbers spec was added.

Can;t you just add |\d?

@Adám: Sort of. Realised it also didn't detect repeated letters if the cases of those letters was different, so needed to normalise case and add parens as well.

Can't you use (?i) to make the regex case insensitive?

Seem to have hit a bug in that regard: https://github.com/rakudo/rakudo/issues/1749

19 bytes

C (gcc), 87 85 83 bytes

Saved two four bytes thanks to ceilingcat.

f(s,p,b,P)char*s,*p;{for(b=s;*s;++s)for(p=b*=*s>64;b&&p<s;b=(*s^*p++)&95?b:0);s=b;}

Try it online!

@ceilingcat Fine suggestion, thanks.

@ceilingcat Thank you.

Julia 0.6, 29 bytes
s->!ismatch(r"\d|(.).*\1"i,s)

Try it online!

Perl 5 with -n -M5.010, 17 bytes
say!/\d|(.).*\1/i

Try it online!
Perl 5 port of my Julia answer.

Powershell, 32 bytes
param($s)$s-notmatch'\d|(.).*\1'

Japt v2.0a0, 8 bytes
v
¶r\L â

Try it
v\n¶r\L â     :Implicit input of string U
v             :Lowercase
 \n           :Reassign to U
   ¶          :Is equal to?
    r         :Remove
     \L       :  Regex /[^a-z]/gi
        â     :Deduplicate

Zsh, 32 bytes
c=${#${(uL)${(s::)1}}};((c<$#1))

Try it online!. Isogram/truthy returns 1, otherwise 0

K (ngn/k), 18 bytes
{(a^,/$!10)~?a:_x}

Try it online!

APL (Dyalog Unicode), 25 20 22 bytes
''≡'(.).*\1|\d'⎕S'&'⍠1

Try it online!
Returns 1 for true, else 0.
Saved 5 bytes thanks to @H.PWiz
Fixed, and saved another byte thanks to @Adám
How?
''≡'(.).*\1|\d'⎕S'&'⍠1 ⍝ Tacit fn
                    ⍠1 ⍝ Ignore case
               ⎕S'&'   ⍝ Search and return the match(es)
   '(.).*\1|\d'        ⍝ For this regex
''≡                    ⍝ And compare to the empty string

Fails on abc1.

Isn't \w → . valid?

If you mean (.).*\1, no. It also fails for abc1 :/

I don't understand. What do you mean by "it also fails"?

If you  Try it Online! you can see it returns 1 for abc1, when it should return 0.

Let us continue this discussion in chat.

CJam, 11 bytes
qelA,s+_L|=

Try it online!
Explanation
The basic idea is to append each digit then check for duplicates. Since the append ensures that each digit is already present once, any further presence of digits will be a duplicate, causing it to return false.
q      e# read the input:            | "MOoSE1"
el     e# convert to lowercase:      | "moose1"
A      e# push 10:                   | "moose1" 10
,      e# range [0,N):               | "moose1" [0 1 2 3 4 5 6 7 8 9]
s      e# string representation:     | "moose1" "0123456789"
+      e# concatenate:               | "moose10123456789"
_      e# duplicate:                 | "moose10123456789" "moose10123456789"
L|     e# union with the empty list: | "moose10123456789" "mose1023456789"
       e# (this gets rid of duplicates)
=      e# Equal to original:         | 0

Red, 76 bytes
func[s][a: charset[#"a"-#"z"#"A"-#"Z"]parse s[any[copy c a ahead not to c]]]

Try it online!

C#, 82 bytes
bool f(string s)=>!!(s.GroupBy(c=>c).Any(c=>c.Count()>1|(!Char.IsLetter(c.Key))));

edit: added test for char
edit: using GroupBy to shorten it by 5 byte

Welcome to PPCG! I think you're missing the requirement that you also need to check that the input contains no digits.

Smalltalk, 57 bytes
Method to be defined in class String:
s^(self select:#isLetter)asUppercase asSet size=self size

This is most likely self-explanatory.

Tcl, 114 bytes
proc I w {lmap c [set L [split $w ""]] {if {[regexp -all -nocase $c $w]>1|![string is alp $c]} {return 0}}
expr 1}

Try it online!

Tcl, 121 bytes
proc I w {lmap c [set L [split $w ""]] {if {[llength [lsearch -al -noc $L $c]]>1|![string is alp $c]} {return 0}}
expr 1}

Try it online!

Still too long for my taste!

Pyth, 17 bytes
.Am&!t/rz0d}dGrz0

Test suite
Explanation:
.Am&!t/rz0d}dGrz0 # Code
  m           rz0 # Map the following over the lowercase input:
      /rz0d       #  Count occurrences of d in lowercase input
     t            #   minus 1
    !             #    inverted (0 -> True)
   &              #     and
           }dG    #      d is in the lowercase alphabet
.A                # Print whether all values are truthy

Python 3 translation:
z=input()
print(all(map(lambda d:not z.lower().count(d)-1and d in "abcdefghijklmnopqrstuvwxyz",z.lower())))

Excel VBA, 82 bytes
An Anonymous VBE immediate window function that takes input from range [A1] and outputs to the VBE immediate window.
[B1:B26]="=Len(A$1)-Len(Substitute(Lower(A$1),Char(Row()+95),""""))":?[Max(B:B)]<2

PHP, 137 Bytes
Try it online!
Code, using ctype_alpha
function f($s){if(ctype_alpha($s)){echo(count(array_unique(count_chars
(strtolower($s))))>2)?0:1;}
else{echo(strlen($s))?0:1;}}

Explanation
(I am absolutely sure this can be shortened)
function f($s){
 if(ctype_alpha($s)){     #ctype_alpha check if the string contains only letters
  echo
   (array_values(array_unique(count_chars(strtolower($s))))!=
      [0,1])?0:1;
   #count_chars, retuns an array with the times each letter is appear in the string
   #array_unique, returns an array with only the unique values
   #the array values will be [0,1] if no letter repeated
 }else{
    #here the empty string gets controlled, and if the string contained numbers
  echo(strlen($s))?0:1;
 }
}

Yes, i will try to reduce the bytes count :D

Perl 5 -p, 20 bytes
$_=!/\d/*!/(.).*\1/i

Try it online!

C# (Visual C# Interactive Compiler), 35 bytes
s=>s.ToDictionary(c=>c<65?c/0:c%32)

Try it online!
Tests for success by presence or absence of an exception.
When a character is a number, a divide-by-zero exception is thrown. Uppercase and lowercase letters normalized. A duplicate key exception will be thrown if the same character is used more than once.

C# (.NET Core), 112 bytes
Here's my (super long) take on this:
c=>{var k=c.ToLower().ToCharArray();return!Enumerable.SequenceEqual(k.Distinct(),k)|!c.Any(m=>char.IsDigit(m));}

It checks if the distinct version of the string is the same as the regular version, and if it is so, return false. Also return false if there is a digit in the string
Try it online!

Python 2, 43 bytes
t=input().lower()
print len(set(t))==len(t)

Try it online!
Expects a quote-delimited string from STDIN as input.
Converts the input to lowercase to make comparisons case-insensitive, then compares the number of unique values to the total number of

C (gcc) -Do=1<<*s%32, 53+12 47+12 = 59 bytes
i;f(char*s){for(i=o;i&o&&*s/58;i^=o)s++;s=!*s;}

Try it online!

Uses the bits of i to store whether a letter has been encountered.
#define o 1<<*s%32  //byte corresponding to letter *s
i;f(char*s){
    for(i=o;        //mark first character
        i&o&&*s/58; //until character duplicate (i&o) or end of string or number (*s/58)
        i^=o)       //toggle the character
        s++;        //step through string
    s=!*s;          //return
}

MBASIC, 202 bytes
1 DIM A(26):INPUT S$:FOR I=1 TO LEN(S$):P=ASC(MID$(S$,I,1))
2 IF P>96 THEN P=P-96
3 IF P>64 THEN P=P-64
4 IF P>26 THEN 7
5 A(P)=A(P)+1:NEXT:FOR I=1 TO 26:IF A(I)>1 THEN 7
6 NEXT:PRINT"true":END
7 PRINT"false"

It's ugly but it works. Merry Christmas!

Swift, 106 bytes
func j(s:String){var a:Set<Character>=[];for c in s{if c<"0"||c>"9"{a.insert(c)}};print(s.count==a.count)}

Try it online!

Vyxal, 5 bytes
⇩:ǍU=

Try it Online!
Explained
⇩:ǍU=
⇩     # input to lowercase
 :    # dup
  ǍU  # remove non-letters and uniquify
    = # are the top two stack items equal?

https://vyxal.pythonanywhere.com/#WyIiLCIiLCLih6nHjcOedSIsIiIsIiJd   4 bytes with the is unique builtin

GolfScript, 30 22 bytes
{32|}%..26,{97+}%--.|=

Try it online!
Link includes test cases.

Thunno, \$ 13 \log_{256}(96) \approx \$ 10.7 bytes
UDgAzsAqkZUJ=

Attempt This Online!
Explanation
UDgAzsAqkZUJ=  # Implicit input
UD             # Convert to lowercase and duplicate
  g     k      # Filter for characters which:
     sAq       #  are in
   Az          #  the lowercase alphabet
               #  (i.e. letters only)
         ZU    # Uniquify
           J   # Join by ""
            =  # Are they equal?

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/