text:
Who can get more points? (Card game KoTH)
A few days ago, I came up with a fun card game to play with my friends. We were having fun playing it, when I thought, "Why not make this a KoTH?" So, here it is!
Overview
In this game, the objective is to get the most points. Your bot starts with 0 points and 20 energy. Every turn (500 in a game), both bots play one card. Some earn you points, some take the opponent's points.
Cards
A=Add 5 points to your score     [Costs 0.1 energy]
R=Remove 5 points from opponent  [Costs 0.1 energy]
H=Half your next score           [Costs 1 energy]
Y=Half opponent's next score     [Costs 1 energy]
D=Double your next score         [Costs 2 energy]
T=Double opponent's next score   [Costs 2 energy]
N=Negate your next score         [Costs 3 energy]
O=Negate opponent's next score   [Costs 3 energy]
S=Shield for 5 turns             [Costs 15 energy]
X=Take five energy from opponent [Gives opponent 10 points]
E=Refill five energy             [Costs 10 points]

How it works
First how would halving your next score or doubling your opponent's next score come in handy? Well, imagine you get 5 points taken away on your next turn. Instead, 2.5 points get taken away. Cool, right? Or, negating your next score would give you 5. If you think your opponent will give themself points, negate their next move!
The order of operations for modifying point values is:

Add all positive or negative point changes
Half if necessary
Double if necessary
Negate if necessary
If shielding and result is negative, change to 0

Attempting to lower the opponent's energy past 0 does not work. There is no upper limit to energy, or lower limit to points. Energy reducing cards are played before other cards, so if Bot A with 17 energy runs shield and Bot B runs take 5 energy, Bot A cannot shield.
Creating a bot
In Javascript, create a new function with whatever name you wish. This function should take 3 parameters:
Array of Numbers (Your coins, Opponent's coins)
Array of Numbers (Your energy, Opponent's energy)
Object (Use for storage between rounds)

Note that there is no way of knowing what cards have been played. You must teach the bot to figure it out by itself!
The way you select a card is by returning a string, containing the letter of the card in uppercase or lowercase. Note that Standard Loopholes (obviously) aren't allowed. If any other value is returned, your bot just does nothing.
Scoring
Every bot will be run against each other bot once. The loser will get 0 points, anbd the winner will get the difference in points added to its total score (Between all rounds). The top 8 will compete in a tournament. In other words, they will each fight one other bot, the four winners will fight another bot, and the two remaining bots will fight for first.
Controller
var botDataList = [
    {
        name: "",
        desc: "",
        run: function(){

        }
    }, {
        name: "",
        desc: "",
        run: function(){

        }
    }
];

function playGame() {
    botSetup();
    for (var i = 0; i < 500; i++) {
        runBots();
    }
    var botA = botDataList[0];
    var botB = botDataList[1];
    console.log("Bot " + botA.name + ": " + botA.points);
    console.log("Bot " + botB.name + ": " + botB.points);
}

function botSetup() {
    for (var b, i = 0; i < 2; i++) {
        b = botDataList[i];
        b.points = 0;
        b.energy = 20;
        b.storage = {};
        b.affectAdd = [];
        b.affectAct = [];
        b.shield = 0;
    }
}

function runBots() {
    var botA = botDataList[0];
    var botB = botDataList[1];
    var resA = botA.run([botDataList[0].points, botDataList[1].points], [botDataList[0].energy, botDataList[1].energy], botDataList[0].storage).toLowerCase();
    var resB = botB.run([botDataList[1].points, botDataList[0].points], [botDataList[1].energy, botDataList[0].energy], botDataList[1].storage).toLowerCase();
    var modA = 0;
    var modB = 0;
    if (resA == 'a' && botA.energy >= 0.1) {
        botA.energy -= 0.1;
        modA += 5;
    } else if (resA == 'r' && botA.energy >= 0.1) {
        botA.energy -= 0.1;
        modB -= 5;
    } else if (resA == 'h' && botA.energy >= 1) {
        botA.energy -= 1;
        botA.affectAdd.push('h');
    } else if (resA == 'y' && botA.energy >= 1) {
        botA.energy -= 1;
        botB.affectAdd.push('h');
    } else if (resA == 'd' && botA.energy >= 2) {
        botA.energy -= 2;
        botA.affectAdd.push('d');
    } else if (resA == 't' && botA.energy >= 2) {
        botA.energy -= 2;
        botB.affectAdd.push('d');
    } else if (resA == 'n' && botA.energy >= 3) {
        botA.energy -= 3;
        botA.affectAdd.push('n');
    } else if (resA == 'o' && botA.energy >= 3) {
        botA.energy -= 3;
        botB.affectAdd.push('n');
    } else if (resA == 's' && botA.energy >= 15) {
        botA.energy -= 15;
        botA.shield += 5;
    } else if (resA == 'x') {
        modB += 10;
        botB.energy = (botB.energy >= 5) ? botB.energy - 5 : 0;
    } else if (resA == 'e' && botA.points >= 10) {
        modA -= 10;
        botA.energy += 5;
    }
    if (resB == 'a' && botB.energy >= 0.1) {
        botB.energy -= 0.1;
        modB += 5;
    } else if (resB == 'r' && botB.energy >= 0.1) {
        botB.energy -= 0.1;
        modA -= 5;
    } else if (resB == 'h' && botB.energy >= 1) {
        botB.energy -= 1;
        botB.affectAdd.push('h');
    } else if (resB == 'y' && botB.energy >= 1) {
        botB.energy -= 1;
        botA.affectAdd.push('h');
    } else if (resB == 'd' && botB.energy >= 2) {
        botB.energy -= 2;
        botB.affectAdd.push('d');
    } else if (resB == 't' && botB.energy >= 2) {
        botB.energy -= 2;
        botA.affectAdd.push('d');
    } else if (resB == 'n' && botB.energy >= 3) {
        botB.energy -= 3;
        botB.affectAdd.push('n');
    } else if (resB == 'o' && botB.energy >= 3) {
        botB.energy -= 3;
        botA.affectAdd.push('n');
    } else if (resB == 's' && botB.energy >= 15) {
        botB.energy -= 15;
        botB.shield += 5;
    } else if (resB == 'x') {
        modA += 10;
        botA.energy = (botA.energy >= 5) ? botA.energy - 5 : 0;
    } else if (resB == 'e' && botB.points >= 10) {
        modB -= 10;
        botB.energy += 5;
    }
    if (botA.affectAct.includes('h')) {
        modA *= 0.5;
    }
    if (botA.affectAct.includes('d')) {
        modA *= 2;
    }
    if (botA.affectAct.includes('n')) {
        modA *= -1;
    }
    if (botA.shield > 0) {
        modA = (modA < 0) ? 0 : modA;
        botA.shield--;
    }
    botA.points += modA;
    botA.affectAct = botA.affectAdd;
    botA.affectAdd = [];
    if (botB.affectAct.includes('h')) {
        modB *= 0.5;
    }
    if (botB.affectAct.includes('d')) {
        modB *= 2;
    }
    if (botB.affectAct.includes('n')) {
        modB *= -1;
    }
    if (botB.shield > 0) {
        modB = (modB < 0) ? 0 : modB;
        botB.shield--;
    }
    botB.points += modB;
    botB.affectAct = botB.affectAdd;
    botB.affectAdd = [];
}

/*  A=Add 5 points to your score     [Costs 0.1 energy]
    R=Remove 5 points from opponent  [Costs 0.1 energy]
    H=Half your next score           [Costs 1 energy]
    Y=Half opponent's next score     [Costs 1 energy]
    D=Double your next score         [Costs 2 energy]
    T=Double opponent's next score   [Costs 2 energy]
    N=Negate your next score         [Costs 3 energy]
    O=Negate opponent's next score   [Costs 3 energy]
    S=Shield for 5 turns             [Costs 15 energy]
    X=Take five energy from opponent [Gives opponent 10 points]
    E=Refill five energy             [Takes 10 points]           */

Is there an upper limit to points?

@HyperNeutrino No, but the max possible in a 500-turn game is 2500

Being a card game enthusiast, this challenge being restricted to Javascript makes me sad.

@J.Sallé Program it in another language, and I'll do like I did in my last challenge and translate. I don't want to restrict people's ability to enter the challenge, it just makes it easier on my part if they;re all in one language.

Shielding protects you for 5 turns. If you're already shielded, should this add to the duration? The controller currently just refreshes the count to 5.

@Veskah Huh, you're right. It should indeed!

This is a bit unclear - Can I choose any card from the 11 that are available to play each turn?

@Quintec Yes you can. I think it might be better to phrase them as moves, rather than cards.

@RushabhMehta Originally you would have 5 "cards" to pick from randomly, but I removed that part so that there would be less randomness

@RedwolfPrograms Does "E", refilling 5 energy and costing 10 points, count as a -10 score?

This could be really interesting as more than a 1v1 contest

Are you only playing a single game?  And are games actually 1v1?  Because the controller only plays games between the first two players, nobody else.

There's a typo in the controller: } else if (resB == 'r' && BotB.energy >= 0.1) { the BotB should be botB.

What is the objective of the game? Is it to get the most points, summed over many rounds? Beat the opponent? Something else? I'm going to have to downvote until this is clarified.

Attempting to lower the opponent's score past 0 does not work. There is no upper limit to energy, or lower limit to points. -- could you clarify?

I'm going through the controller some more, and it's completely broken. There are so many things that don't work. None of the 'affects[sic]' work because you add them to affectAdd and read them from affectAct. When adding up the score modifier, sometimes you increment modA or modB and sometimes modA.points or modB.points. Did you even try running this before you posted it?

@Omegastick affectAct and affectAdd things are OK because the effects have to be applied at the next turn, not this turn. But you're right about modA.points and modB.points. They should definitely be modA and modB instead. The rest looks fine to me; at least I can run my 2500-scoring bot against the "greedy" without problems after fixing modX myself.

Oh, there's also modB.energy. That one should be botB.energy instead.

Does doubling your next score stack? As in can I double for two rounds to get x4?

@RedwolfPrograms The controller has some incredibly silly code duplication. I fixed it up a bit, but I'm sure there are ways to make this even better. (I haven't tested for correctness, though, since I just threw this together in 5 minutes. I can't imagine screwing anything up, but treat this as more of a proof of concept rather than a replacement anyway. (This is in response Redwolf's "I needed to have 1 if for every card for both bots" - you didn't ;) ))

What precisely does "next score" mean? What does shield do? In "Energy reducing cards are played before other cards", surely every card except X is an energy reducing card? IMO this question still needs a few days in the sandbox.

Should it be possible for negative scores to happen? I've found a lot of examples when running Doom vs Greedier...

@RedwolfPrograms Also, what if my move renders the opponent with not enough score to execute his move? Whose move executes first?

@RedwolfPrograms "Attempting to lower the opponent's score past 0 does not work." Doom disagrees - OX on an opponent with 0 score results in a negative score...

Speaking of which, I think @Bubbler 's Doom has successfully doomed this challenge to failure - I don't think you can win against it.

@J.Sallé Or someone else. If the bot is interesting enough. /// (or just write a simple other-language wrapper...)

@PeterTaylor X is the energy reducing card.

@Barbarian772 It does stack. You could also end up with x1/4

@RushabhMehta I'm going to fix that part of the code. Sorry, didn't test it more than a few simple games

Could be way more interesting if the game was more card-game-like, i.e. design a deck and make a bot play with it strategically. Somewhat reminds me of Castle Wars series.

@Bubbler I would love a Castle Wars-esque KOTH!

@RedwolfPrograms you might havemissed this question: Does "E", refilling 5 energy and costing 10 points, count as a -10 score?

@Quintec yes, so O or N can cause you to get points from it

playing only a single round guarantees the winner will be chosen primarily by luck.  why not play each matchup 1000x times and use avg difference?  this is the whole benefit of having computer programs rather than humans playing...

Doom: OX (Negate opponent - Take energy) Combo
function(coins, energy, obj) {
    let mycoin = coins[0]
    let yourcoin = coins[1]
    let myenergy = energy[0]
    let yourenergy = energy[1]
    if (obj.last === 'O') obj.last = 'X'
    else if (myenergy >= 3 && (yourcoin > 0 || yourenergy > 0)) obj.last = 'O'
    else if (mycoin >= 10 && myenergy < 3) obj.last = 'E'
    else obj.last = 'A'
    return obj.last
}

If a player has zero points AND zero energy, it can do absolutely nothing. This bot, named "Doom", aims to put the opponent in this doomed state, and then happily accumulates its own score.
Here is a run against The Classic. Doom wins against Classic with around 1600 - 1800 score, while Classic is always stuck at 0 score and 0 energy.
Doom is arguably the strongest among the four bots posted so far (Classic, Greedy, Greedier and Doom), but my guess is it's still susceptible to some kind of anti-Doom.

I feel like shielding could beat this, but imo shielding seems too expensive to really do you any harm

I can't beat this bot even when playing against it myself ._.

@Bubbler I literally was about to post a bot very similar to this right now. lol I'mma do it anyways

I don't think an anti-Doom exists, because the intuitive idea of negating Doom's negation doesn't work for some reason (I still get -10'd). There are a lot of different things I've tried as well ([XO], [NR], S..., [AS], H[OX], H..., [X]), but all of them fail. I think this just solves the challenge outright.

@Alion agreed. This doesn't seem like a terribly interesting KOTH

@RushabhMehta It's a shame, really. Without this optimal opening that you can't do anything against and that leaves both players in a drawn position and unable to make progress (if used by both of them), it could've been fairly interesting I think.

@Alion Yup. You end up in a X then E loop that doesn't end.

What about looping E during the X, and A during the O? Then, you'd get energy back and the O would give you the ten points

@RedwolfPrograms That is a disaster! Doom starts its OX loop immediately, so an AE loop doesn't even complete one iteration - you're only at 5 points when trying to do your first E, but Doom steals 10 on turn 2 and makes you unable to afford an E, leaving you with -5 points and 14.9 energy!! Moreover, you wouldn't be able to afford a 10-point-cost action anyway!

Actually, after re-reading that a couple of times I'm starting to feel like you yourself don't even know how your game works anymore... I have no clue what you mean by O giving you 10 points.

It seems that Doom is in fact beatable - I'm just incompetent. Whoops...

Doom-RX
function(coins, energy, obj) {
    let mycoin = coins[0]
    let yourcoin = coins[1]
    let myenergy = energy[0]
    let yourenergy = energy[1]
    if(!obj.last) obj.last = ' RXRX';
    if(obj.last.length > 1) obj.last = obj.last.substring(1, 5)
    else if (obj.last === 'O') obj.last = 'X'
    else if (myenergy >= 3 && (yourcoin > 0 || yourenergy > 0)) obj.last = 'O'
    else if (mycoin >= 10 && myenergy < 3) obj.last = 'E'
    else obj.last = 'A'
    return obj.last.substring(0,1)
}

Almost entirely derivative of Bubbler's answer, but with a hardcoded opening sequence that counters that specific entry. Here's this run against Doom.
Essentially, using R has less energy cost than O, so when both play OX against each other after the 4th turn Doom is stuck at 0/0, while Doom-RX survives at -30/1.8 and is able to recover.
RXRX isn't the only sequence that works against Doom, but it does look to be among the most robust 4-letter sequences and I liked it best aesthetically. I'm sure there's a more effective approach to this than hard coding, though.
Overall OX seems overbearingly powerful; I'd be surprised if an entry that didn't use it could beat this kind of strategy.

...it seems that I've managed to bail on this approach in my attempts too early. Nice find!

The TIO link is Classic vs Doom OX

@Quintec Thanks for the heads up, fixed.

Just a heads up that this is now a rock paper scissors game

Greedy
function(coins, energy, obj) {
    if (energy[0] < 0.2) return 'E';
    else return 'A';
}

I'm probably misunderstanding the game, but I don't see any reason not to just increase your own points every round.

Oh, I understood 'negate the next score' to mean 'if your score would change next turn, instead don't change it'. But apparently we were both wrong, it looks like the controller inverts the next modifier, so I would lose 5 points instead of gaining them. A bot that just plays 'O' every turn might beat this, but because of energy problems it might not.

Well, yes. I am sorry, I though it meant your opponent's next acquired score. +1, I currently see no obvious way to get an edge over your bot.

Greedier: NE (Negate self - Refill energy) Combo
function(coins, energy, obj) {
    let mycoin = coins[0]
    let myenergy = energy[0]
    if (mycoin >= 10 && (obj.last === 'N' || myenergy <= 3.1)) obj.last = 'E'
    else if (mycoin >= 20 && myenergy >= 8) obj.last = 'N'
    else obj.last = 'A'
    return obj.last
}

How it (may) work
N : Energy -= 3
E : Energy += 5; Points += -(-10)
---------------------------------
    Energy += 2; Points += 10

So we don't even need to worry about being out of energy.
Here is the result against Greedy. Greedy gets only 2410 since it has to refill its energy from time to time. On the other hand, Greedier achieves full 2500 score if the opponent doesn't interfere.
The code above includes a bit of anti-failure measures:

If it's getting out of energy somehow, force refill energy (E).
If it's out of points, try getting some basic points (A).
Use negate (N) only if it has enough energy to run it even if the opponent plays drain energy (X) i.e. 3 + 5 = 8, AND it has enough coins to run E next turn even if the opponent plays double opponent (T) + reduce opponent 5 (R) i.e. 10 + 5 * 2 = 20.

Doom EX (Rock, paper, scissors!)
function(coins, energy, obj) {
    let mycoin = coins[0]
    let yourcoin = coins[1]
    let myenergy = energy[0]
    let yourenergy = energy[1]
    if(!obj.last) obj.last = ' EXEX';
    if(obj.last.length > 1) obj.last = obj.last.substring(1, 5)
    else if (obj.last === 'O') obj.last = 'X'
    else if (myenergy >= 3 && (yourcoin > 0 || yourenergy > 0)) obj.last = 'O'
    else if (mycoin >= 10 && myenergy < 3) obj.last = 'E'
    else obj.last = 'A'
    return obj.last.substring(0,1)
}

All credit goes to @Bubbler and @ripkoops, I just wanted to point this out. This version manages to beat Doom RX, but loses to Doom OX. Looks like this KOTH is rock paper scissors in disguise...
RX vs EX

Now it's getting slightly interesting, except that all the top tiers are variants of Doom...

@Bubbler I'm still looking for the "gun" in rock, paper, scissors... what, you've never cheated in that game? :P

An XRAXA or XRXAA variant wins against all 3 convincingly (has plenty of other counters though). Wonder how deep this rabbit hole goes.

@ripkoops huh, nice. This could be quite interesting actually. Time to make a directed graph... and maybe turn this into a whole other code golf challenge xD

The Classic (aka Random Player)
function(coins, energy, obj) {
    if (energy[0]<1) return ['A','R','X'][(Math.random()*3)|0];
    else if (energy[0]<2) return ['A','R','H','Y','X'][(Math.random()*5)|0];
    else if (energy[0]<3) return ['A','R','H','Y','D','T','X'][(Math.random()*7)|0];
    else if (energy[0]<10) return ['A','R','H','Y','D','T','X','N','O'][(Math.random()*9)|0];
    else if (energy[0]<15) return ['A','R','H','Y','D','T','X','N','O','E'][(Math.random()*10)|0];
    else return ['A','R','H','Y','D','T','X','N','O','E','S'][(Math.random()*11)|0];
}

Are you sure you didn't mean energy[0]?

@RedwolfPrograms Yes I did. Oops, I'll fix momentarily


text:
Print a Quinella Table

ALERT: IN CASE YOU DOUBT, NO PUN ON "QUINE" IS INTENDED

In regulated horse-racing for gambling, bets called Quinella bets exist and in which a person bet on the first two places of a race. In racecourses, usually there is a display which shows the odds of a specific combination as below:

(This picture is a cropped picture from Hong Kong Jockey Club. QIN stands for Quinella)
Challenge
Write a program or function, receiving either lines of strings or an array, print or return an ASCII Quinella table with the following format:

 QUINELLA  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  | 10  | 11  | 12  | 13  | 14  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
     | 8\1 | 162 | 7.2 | 11  | 109 | 4.5 | 6.0 | 11  | 999 | 11  |     |     |     |     |  1
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
  9  | 37  | 9\2 | 11  | 999 | 41  | 350 | 75  | 24  | 999 | 31  |     |     |     |     |  2
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 10  | 8.2 | 84  |10\3 | 75  | 999 | 85  | 48  | 8.1 | 138 | 191 |     |     |     |     |  3
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 11  |     |     |     |11\4 | 45  | 6.4 | 999 | 287 | 473 | 60  |     |     |     |     |  4
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 12  |     |     |     |     |12\5 | 15  | 8.9 | 40  | 175 | 378 |     |     |     |     |  5
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 13  |     |     |     |     |     |13\6 | 26  | 999 | 15  | 860 |     |     |     |     |  6
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 14  |     |     |     |     |     |     |14\7 | 727 | 100 | 37  |     |     |     |     |  7
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
     |  8  |  9  | 10  | 11  | 12  | 13  |     |  8  |  9  | 10  | 11  | 12  | 13  | 14  |

In this challenge, the numbers in the middle are calculated from the input by a specific algorithm, which will be explained later.
Specification
Input: Your program or function must receive one of the two formats as below:

Lines of Strings: The first line will be <number of horses> <number of bets>, following by <number of bets> lines of <horse 1> <horse 2> <amount of bet>.

Example:

10 100
1 2 100
3 4 500
5 6 100
7 8 2000
9 10 10
(... 95 more lines)

Array: An array or tuple, with 3 elements, [<number of horses>, <number of bets>, <bets>], where <bets> is a 2d array consisting of <number of bets> elements, each element consists of 3 elements, [<horse 1>, <horse 2>, <amount of bet>]. As a special rule for functions, passing the tuple as 3 arguments is allowed.

Example:

[10, 100, [
 [1, 2, 100],
 [3, 4, 500],
 [5, 6, 100],
 [7, 8, 2000],
 [9, 10, 10],
 ... 95 more elements
]]

You may assume all inputs are valid.

You may assume 1 <= <horse 1> < <horse 2> <= <number of horses> in both cases.

You may assume 9 <= <number of horses> <= 14 in both cases.

Processing: The odds for each quinella pair <horse 1>, <horse 2> (unordered, i.e. 1,2 and 2,1 are considered identical) is calculated as follows:
Odds = <Total bet amount of all pairs> / <Total bet amount of the pair> / 2
Maximum Odds: 999, Minimum Odds: 1.1

In case you doubt, the odds will be 999 if <Total bet amount of the pair> == 0.
The result should be rounded to the nearest 0.1 if Odds < 9.95 (in this case, the .0 must be retained if necessary), and to the nearest integer if Odds >= 9.95.
Output: Replace each bold-and-italic number pair with the corresponding odds calculated in the previous step. Leave the cell blank if any of the number in the pair is larger than <number of horses>.

 QUINELLA  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  | 10  | 11  | 12  | 13  | 14  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
     | 8\1 | 1,2 | 1,3 | 1,4 | 1,5 | 1,6 | 1,7 | 1,8 | 1,9 |1,10 |1,11 |1,12 |1,13 |1,14 |  1
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
  9  | 8,9 | 9\2 | 2,3 | 2,4 | 2,5 | 2,6 | 2,7 | 2,8 | 2,9 |2,10 |2,11 |2,12 |2,13 |2,14 |  2
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 10  |8,10 |9,10 |10\3 | 3,4 | 3,5 | 3,6 | 3,7 | 3,8 | 3,9 |3,10 |3,11 |3,12 |3,13 |3,14 |  3
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 11  |8,11 |9,11 |10,11|11\4 | 4,5 | 4,6 | 4,7 | 4,8 | 4,9 |4,10 |4,11 |4,12 |4,13 |4,14 |  4
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 12  |8,12 |9,12 |10,12|11,12|12\5 | 5,6 | 5,7 | 5,8 | 5,9 |5,10 |5,11 |5,12 |5,13 |5,14 |  5
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 13  |8,13 |9,13 |10,13|11,13|12,13|13\6 | 6,7 | 6,8 | 6,9 |6,10 |6,11 |6,12 |6,13 |6,14 |  6
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 14  |8,14 |9,14 |10,14|11,14|12,14|13,14|14\7 | 7,8 | 7,9 |7,10 |7,11 |7,12 |7,13 |7,14 |  7
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
     |  8  |  9  | 10  | 11  | 12  | 13  |     |  8  |  9  | 10  | 11  | 12  | 13  | 14  |

Each cell is 5 characters wide.
You must center the odds, and if you cannot balance the margins, make left margin 1 character less wider than right margin.

Test Cases
Here is a TIO driver which generates random test cases. No hard-coded test cases will be provided.
Winning Criteria
Shortest code in each language wins as per the rules of code-golf challenges. No standard loopholes allowed.

I take it that 9 <= number of horses <= 14 based on the test generator, and the output format? Additionally, is input in the form of a tuple (number of horses, number of bets, [array of bets]) acceptable?

@Οurous I think yes. I'll modify to clarify this.

Can the three-element sub-arrays be taken as tuples? And may the bet values be taken as floats-with-integer-value instead of integers? Eg: [[Int]] becomes [(Int,Int,Real)]

@Ourous of course yes (for both questions) (I'd say array and tuple are to be treated the same here but when I was building this challenge I was coding with JavaScript so...)

JavaScript (ES8), 321 bytes
Takes input as (number_of_horses)(bets). The number of bets is not taken.
n=>b=>' QUINELLA  '+(y=e='',g=(x,y)=>b.map(([X,Y,b])=>k+=X-x|Y-y?0:b,k=-(x>n|y>n))|k,F=x=>y>16?e:`|+
`[x?y&1:2]+(Y=y/2,s=y&1?'-----':(x%15|Y%8?x?Y>7?x>7?x:x<7?x+7:e:x-Y?y?x<15?~g(x>Y?Y:x+7,x>Y?x:Y+7)?(k=.5/k*g())<999?k.toFixed(k<9.95):999:e:Y:x:x+7+'\\'+x:y-2?Y+7:e:e)+e).padStart(s[2]?4:3).padEnd(5)+F(++x<16?x:!++y))(2)

Try it online!
How?
Main part
n => b =>                       // n = number of horses; b[] = bet array
  ' QUINELLA  ' + (             // append header
    y = e = '',                 // e is the empty string; start with y = '', coerced to 0
    F = x =>                    // F = main recursive function, taking x
      y > 16 ?                  //   if y is greater than 16:
        e                       //     return an empty string and stop recursion
      :                         //   else:
        `|+\n`[x ? y & 1 : 2]   //     append a linefeed if we are at the beginning of a row
        + (                     //     or either '|' or '+' depending on the parity of y
          Y = y / 2,            //     define Y = y / 2
          s =                   //     define s:
            y & 1 ?             //       if y is odd:
              '-----'           //         s = 5 hyphens
            :                   //       else:
              [cell content]    //         s is set to the content of the cell
        )                       //
        .padStart(s[2] ? 4 : 3) //   prepend leading spaces
        .padEnd(5) +            //   append trailing spaces
        F(++x < 16 ? x : !++y)  //   append the result of a recursive call
  )(2)                          // initial call to F() with x = 2

Cell content
The cell content is computed with a huge cascade of ternary operators, which is neither easy nor very interesting to detail here.
One key part in there is the formatting of a bet:
~g(                             // invoke g():
  x > Y ? Y : x + 7,            //   first horse
  x > Y ? x : Y + 7             //   second horse
) ?                             // if g() didn't return -1:
  (k = .5 / k * g())            //   compute amount_of_all_pairs / amount_of_this_pair / 2
  < 999 ?                       //   if the result is less than 999:
    k.toFixed(k < 9.95)         //     output it with the proper number of decimal places
  :                             //   else:
    999                         //     force result to 999
:                               // else:
  e                             //   output an empty cell

Bet amount processing
The helper function \$g\$ computes the total bet amount for a given pair of horses, or the total bet amount of all pairs when invoked with no argument. If at least one of the horses is not valid, it returns \$-1\$ instead.
g = (x, y) =>                   // x = 1st horse, y = 2nd horse
  b.map(([X, Y, b]) =>          // for each bet of amount b on horses (X, Y):
    k +=                        //   update k:
      X - x | Y - y ?           //     if (x, y) is not matching (X, Y):
        0                       //       add 0 to k
      :                         //     else:
        b,                      //       add b to k
    k = -(x > n | y > n)        //   start with k = 0 if both x and y are valid horses
                                //   otherwise, start with k = -1
  ) | k                         // end of map(); return k

Holy ternary Batman! o.Ô

@KevinCruijssen I actually gave up detailing all these ternary operators. :)

Python 2, 500 448 444 bytes
R=range(1,15)
h,_,b=input()
Q=eval(`[['']*16]*9`)
Q[8][1:6]=R[7:13];Q[8][8:16]=R[7:]
for i in R:
 if i<8:Q[i][i]=`7+i`+'\\'+`i`;Q[i][::15]=[['',7+i][i>1],i]
 for j in R:v=sum(v*((A,B)==(i,j))for A,B,v in b);x=min(999,0**v*999or.5*sum(zip(*b)[2])/v);X,Y=i<j<=h and[i,j-7,j,i-7][i>7::2]or(0,0);Q[X][Y]=x<10and round(x,1)or int(x+.5)
Q[0]=[' QUINELLA  ']+R[1:]+['']
for l in Q:print('-----+'*15+'-----\n')*(l<[' '])+'|'.join(map('{:^5}'.format,l))

Try it online!

I cannot test right now, but would x+.5 work over round(x)?

@Mr.Xcoder Yeah, thanks :)

Clean, 498 ... 483 bbytes
Doesn't take the number of bets.
import StdEnv,Text
q=""
j=join
$h a=replaceSubString" 0""  "(" QUINELLA"+(j("\n"+j"+"(repeatn 16"-----")+"\n")[j"|"[q<+cjustify 5[c\\c<-: ?h a u v]\\v<-[0..15]]\\u<-[0..8]])%(9,9^9))
?h a u v|u<1=q<+v rem 15|v>14=q<+u rem 8|u>7|v>7=q<+v=q<+(v+7)*sign(v rem 7)
|u==v=u+7<+"\\"<+v|v<1|u>1=q<+u+7=q
#p=sort[k+if(u>=v)7 0\\k<-[u,v]]
#r=sum[z\\(x,y,z)<-a|[x,y]==p]
|r>0.0#r=sum(map thd3 a)/r/2E0
|r<9.95=snd(sort[(abs(e-r),e<+".0")\\e<-[1.1,1.2..1E1]]!!0)%(0,2)=q<+toInt r
|p!!1<h="999"=q

Try it online!
Explained:
q = ""                  // define `q` as the empty string
j = join                // define `j` as the join function
$ h a                   // function $ of horses `h` and array `a`
 = replaceSubString     // replace all
  " 0"                  // zeroes with spaces before them
  "  "                  // with two spaces
  (                     // (in the string)
   " QUINELLA" +        // " QUINELLA" prepended to
   (                    // (the string created by)
    j                   // joining arg2 with arg1
     (                  // (the separator string)
      "\n" +            // newline prepended to
      j "+"             // joining arg2 with plusses
       (repeatn 16      // a list with 16 of
        "-----")        // string with 5 dashes
      + "\n"            // prepended to a newline
     )
     [                  // (a list made out of)
      j "|"             // joining arg2 with vertical pipes
       [                // (a list made out of)
        q <+            // stringifying
        cjustify 5 [    // center-aligning a list of
         c              // character `c`
         \\ c <-:       // for every `c` in the string
          ? h a u v     // (the thing that goes in the cell)
        ]
        \\ v <- [0..15] // for every `v` from 0 to 15
       ]
       \\ u <- [0..8]   // for every `u` from 0 to 8
     ]
   ) % (9, 9^9)         // drop 9 elements off the front
  )
? h a u v               // function ? of `h` `a` `u` and `v`
 | u < 1                // if `u` is zero
  = q <+ v rem 15       // stringify `v` modulo 15
 | v > 14               // if `v` is 15
  = q <+ u rem 8        // stringify `u` modulo 8
 | u > 7                // if `u` is 8
  | v > 7               // if `v` is more than 7
   = q <+ v             // stringify `v`
  = q <+                // otherwise stringify
  (v+7) *               // `v` plus 7 unless
  sign(v rem 7)         // `v` is 7 or zero
 | u == v               // if `u` equals `v`
  = u + 7 <+            // stringify `u` plus 7 and append
  "\\" <+ v             // a slash and the stringification of v
 | v < 1                // if `v` is zero
  | u > 1               // if `u` is more than 1
   = q <+ u + 7         // stringify `u` + 7
  = q                   // empty string
 # p =                  // define `p` as
  sort                  // the sorted
   [                    // (list of horse numbers)
    k +                 // k plus
    if(u >= v)
     7                  // if u >= v, 7
     0                  // else zero
    \\ k <- [u, v]      // for every `k` in u and v
   ]
 # r =                  // define `r` as
  sum                   // the sum of
   [                    // (the bets on those horses)
    z                   // the bet `z`
    \\ (x, y, z) <- a   // for every subarray
    | [x, y] == p       // where the horse pair matches `p`
   ]
 | r > 0.0              // if `r` is greater than zero
  # r =                 // redefine `r` as
   sum                  // the sum of
    (map thd3 a)        // every bet
   / r                  // divided by the previous `r`
   / 2E0                // divided by two
  | r < 9.95            // if r is less than 9.95
   = snd                // the second element of
    (                   // (the tuple with the closest matching odd)
     sort               // sort the
      [                 // (list of potential odds)
       (                // (tuple with)
        abs(e - r)      // the difference between `r` and the odd `e`
        , e <+ ".0"     // and the stringification of `e`
       )                // for every `e` in the list of odds
       \\ e <- [1.1, 1.2..1E1]
      ] !! 0            // the first element
    ) % (0, 2)          // "round" the number
  = q <+ toInt r        // otherwise stringify and round `r`
 | p!!1 < h             // if the bet was actually zero
  = "999"               // the odds are 999
 = q                    // otherwise there isn't a horse

source: Stack Exchange

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

sort: votes


text:
Simulate Casio S-VPAM calulator
It is 20th anniversary of Casio's S-VPAM calculators and it is worth celebrating.
Task: Process input string as Casio S-VPAM calculator does. The infix notation and precedence of mathematical operations must be followed. Angle values are expected in radians. Since there were multiple updates, sin 15, sin15 and sin(15 are equally parsed as sin(15) and spaces are thus ignored.
Input: String or Char array
Output: Array of 8-bit numbers representing the segments states on the 7-segment display

      A B C D E F G DP | representation | visualization
blank 0 0 0 0 0 0 0 0  |   0 / 00       | " " or "_"
minus 0 0 0 0 0 0 1 0  |   2 / 02       | "-"
   0  1 1 1 1 1 1 0 0  | 252 / FC       | "0"
   0. 1 1 1 1 1 1 0 1  | 253 / FD       | "0." or "0,"
   1  0 1 1 0 0 0 0 0  |  96 / 60       | "1"
   1. 0 1 1 0 0 0 0 1  |  97 / 61       | "1."
   2  1 1 0 1 1 0 1 0  | 218 / DA       | "2"
   2. 1 1 0 1 1 0 1 1  | 219 / DB       | "2."
   3  1 1 1 1 0 0 1 0  | 242 / F2       | "3"
   3. 1 1 1 1 0 0 1 1  | 243 / F3       | "3."
   4  0 1 1 0 0 1 1 0  | 102 / 66       | "4"
   4. 0 1 1 0 0 1 1 1  | 103 / 67       | "4."
   5  1 0 1 1 0 1 1 0  | 182 / B6       | "5"
   5. 1 0 1 1 0 1 1 1  | 183 / B7       | "5."
   6  1 0 1 1 1 1 1 0  | 190 / BE       | "6"
   6. 1 0 1 1 1 1 1 1  | 191 / BF       | "6."
   7  1 1 1 0 0 0 0 0  | 224 / E0       | "7"
   7. 1 1 1 0 0 0 0 1  | 225 / E1       | "7."
   8  1 1 1 1 1 1 1 0  | 254 / FE       | "8"
   8. 1 1 1 1 1 1 1 1  | 255 / FF       | "8."
   9  1 1 1 1 0 1 1 0  | 246 / F6       | "9"
   9. 1 1 1 1 0 1 1 1  | 247 / F7       | "9."
  deg 1 1 0 0 0 1 1 0  | 198 / C6       | "o"
 frac 0 0 1 1 0 0 0 0  |  48 / 30       | "/"
      A B C D E F G DC | representation | visualization

Input string is split in substrings as follows:
X : number decimal separator is either dot or comma, whatever comes first. Using both results in Syntax Error
n : one-digit number or result in braces
command : string operator
Special commands:

Power X^n: X to power n
Root nsqrtX: nth root of X
Exponent: XEY X times 10^Y
Angles: XD return X degrees in radians; XG return X grads in degrees
Degrees: XdYdZd return string in MoNoXo format. M is number of whole degrees(hours), N<60 number of whole minutes and X seconds (may be decimal) If part of command return as decimal value. Xd may be omitted returning 0oNoXo string instead
Goniometric functions funX: 'function of X. -h suffix triggers hyperbolic function a- prefix triggers inverse function.
Logarithms: lnX natural logarithm of X; logX decadic logarithm of X
Fractions: X\Y,X\Y\Z: If XandYandZ are integers return "A/B" where A and B are lowest integers possible, otherwise return default format
Combinatorics: X! Factorial of X; XCY Y-combinations of X; XPY Y-permutations of X. X and Y must be integer, otherwise return "Syntax error"
Constants: pi, e
Random number: Ran# return uniformally distributed value U(0,1)
Absolute value: AbsX

Non-necessary zeros, multiplications and trailing brackets may be omitted
Test:
Input                   | Result HEX array                          | Result Visualized
1+6                     | 00 00 00 00 00 00 00 00 00 00 E0 00 00 00 | "          7   "
sin-.5pi                | 00 00 00 00 00 00 00 00 00 02 60 00 00 00 | "         -1   "
cosh180D                | 00 60 61 B6 F6 60 F6 B6 F2 DA FE 00 00 00 | " 11.59195328   "
piD                     | 00 00 F2 C6 FE C6 DA F7 E0 F2 C6 00 00 00 | "  3o8o29.73o   "
-25e-4sin 1-cos 59^(5-7 | 02 61 FC F2 60 B6 E0 E0 E0 66 F2 02 60 FC | "-1.031577743-10"

Rules:
Standard rules apply: Loopholes forbidden, the shortest answer in bytes win.

Hello and welcome to PPCG! I see potential in this challenge, but as it stands it appears a bit rough around the edges. You could use the sandbox to fine tune your challenge and get community input on best practices and standard rules.

I'd suggest adding a diagram to clarify which stroke a register corresponds to, e.g. the top stroke is denoted A.

@user202729 Thank you very much for your comments. I've removed the bonus part and updated the angles part. My old Casio has malfunctioning display and the new one has natural-VPAM. I'll process it soon

Regarding the "stack error" I am not sure about this limitation. I am sure there was a limit on the length of the input "string".

Hi, and Welcome to PPCG! It's your challenge so you're the boss... you can decide that the only limitations are the ones you outlined in the challenge, or make it more like a simulator by enforcing actual limitations/bugs. It's your decision, just clarify what your intent is and make sure to edit the question accordingly (ie "no need to enforce stach error for >23 nested parentheses" or "must throw a Stack Error when >23 nested parentheses".

@JayCe The challenge was intended to celebrate the S-VPAM calculators with all their features and bugs.

I'm temporarily vote to close the challenge as "unclear what you're asking", when it's clear enough I will retract the close vote or vote to reopen.

(summary of all comments above: remaining issues: 1. What should x\y\z do (what's A and B?) 2. What does a number displayed on the screen, such as -1.031577743-10, mean (last 3 digits are the exponent I suppose) 3. Stack error? 4.  sin -> sin Ans? 5. What exactly is the priority of the "special" operators? ||| some points that is clear enough but I believe is incorrect, it's up to you to decide to keep the original specification or change it: 1. P C or ! on non natural should give Math error.

Decimal point is always ., not ,. 3. I think the calculator use sin¯¹ not asin. 4. I think X°Y° is interpreted as X°Y°0° not 0°X°Y°, 5. The "XG return X grads in degrees" part doesn't look correct, I think it should be "in radians". )

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


text:
Crown hundred crownty crown
I noticed a certain game had a peculiar life counter, which instead of stopping at 999, gained a new digit – the next number was crown hundred or 00. After 99 came crown hundred crownty (0) and the last number, after 9, was crown hundred crownty crown or , which would be 1110 in decimal.
Your task is to write a program or a function that outputs this counter.
Given an integer from the range [0,1110] (inclusive on both ends), output a three character string where

every character is from the list 0123456789
the crown () can only appear as the leftmost character or when there's a crown to the left of it
when this number is read as a decimal number but with the crown counting as 10, you get back the original number

Test cases
   0 → "000"
  15 → "015"
 179 → "179"
 999 → "999"
1000 → "00"
1097 → "97"
1100 → "0"
1108 → "8"
1110 → ""

You may use any non-decimal character instead of the crown. To encourage pretty printing, the crown character (UTF8 byte sequence "\240\159\145\145") counts as one byte instead of four. Your program doesn't have to work for numbers outside the valid range.
This is code-golf, so the shortest answer, measured in bytes, wins!

Oh, Super Mario 3D Land!

@Deusovi I was actually thinking about the follow-up game, Super Mario 3D World, but well guessed!

This should be the IMO number for Boaty McBoatFace.

The bonus is multiplied by the number of crowns in the code, right?

@EriktheOutgolfer As I understand it, if the output contains the crown, you may subtract  3 from the byte count.

@Mr.Xcoder I mean, a crown is 4 bytes, so, if the bonus is only applied once, but you need to use many crowns, you need to use a variable (if that's possible).

@EriktheOutgolfer I changed the wording so the crown counts as one byte, no matter how many there are.

The "numbering" system here appears to be internally inconsistent - why is 999 followed by C00 (C is the crown), but C99 is followed by CC0, but 99 is not followed by C0, but… this looks like it's trying to look like base 11, with the crown being the ten-value digit.

@JeffZeitlin it's a redundant decimal system, where a number may have more than one representation (even disregarding leading zeroes). The crown is then reserved as a surprise element, only used when absolutely needed.

@JeffZeitlin It's a reference to SMB. That would make a more complex version of this challenge...

05AB1E, 20 18 bytes
₄‹i₄+¦ëTð.;„1 „  :

Uses spaces for crowns.
Try it online or verify all test cases.
Explanation:
₄‹i               # If the (implicit) input is smaller than 1000:
   ₄+             #  Add 1000 to the (implicit) input
     ¦            #  And remove the leading 1 (so the leading zeros are added)
                  #   i.e. 17 → 1017 → "017"
  ë               # Else:
   Tð.;           #  Replace the first "10" with a space " "
                  #   i.e. 1010 → " 10"
                  #   i.e. 1101 → "1 1"
                  #   i.e. 1110 → "11 "
       „1 „  :    #  Replace every "1 " with "  " (until it no longer changes)
                  #   i.e. " 10" → " 10"
                  #   i.e. "1 1" → "  1"
                  #   i.e. "11 " → "   "

JavaScript (Node.js), 50 bytes
f=(n,p=1e3)=>n<p?(n+p+'').slice(1):'#'+f(n-p,p/10)

Try it online!
TIO was based on Arnauld's answer. Show  as #.

Nice recursive approach!

JavaScript (ES6),  62 46  44 bytes
Saved 2 bytes thanks to @nwellnhof
Outputs crowns as x characters.
n=>(n+1e4+'').replace(/1+0/,'xxx').slice(-3)

Try it online!
How?
We add \$10000\$ to the input, coerce it to a string, look for the /1+0/ pattern and replace it with xxx. Finally, we return the 3 trailing characters.
Examples:
$$\begin{align}&0 &\rightarrow &\text{ "}\color{red}{\text{10}}\text{000"} &\rightarrow &\text{ "xxx000"} &\rightarrow &\text{ "000"}\\
&123 &\rightarrow &\text{ "}\color{red}{\text{10}}\text{123"} &\rightarrow &\text{ "xxx123"} &\rightarrow &\text{ "123"}\\
&1023 &\rightarrow &\text{ "}\color{red}{\text{110}}\text{23"} &\rightarrow &\text{ "xxx23"} &\rightarrow &\text{ "x23"}\\
&1103 &\rightarrow &\text{ "}\color{red}{\text{1110}}\text{3"} &\rightarrow &\text{ "xxx3"} &\rightarrow &\text{ "xx3"}\\
&1110 &\rightarrow &\text{ "}\color{red}{\text{11110}}\text{"} &\rightarrow &\text{ "xxx"} &\rightarrow &\text{ "xxx"}
\end{align}
$$

s.replace(/./g,\#`)is neat... I hadArray(s.length+1).join`#``, and my regex was longer too! Nice work, +1

@Mr.Xcoder It was actually a terrible idea. But it took more than one year to fix it. :D

Shakespeare Programming Language, 763 692 690 689 683 bytes
,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]Ford:Listen tothy!Ajax:You big big cat.Scene V:.Ajax:Remember the remainder of the quotient betweenI twice the sum ofa cat a big big cat.Ford:You be the quotient betweenyou twice the sum ofa cat a big big cat.Ajax:You be the sum ofyou a pig.Be you nicer zero?If solet usScene V.Ford:You big big cat.[Exit Ajax][Enter Page]Page:Recall.Ford:You be I.Scene X:.Page:Recall.Am I nicer zero?If notopen heart.If notlet usScene L.Ford:You big big big big big cat.Speak thy.Am I worse a cat?If soyou zero.Scene L:.[Exit Page][Enter Ajax]Ford:You be the sum ofyou a pig.Is you nicer a cat?[Exit Ajax][Enter Page]Ford:If solet usScene X.

Try it online!
Uses " " instead of crowns. At the cost of 4 more bytes, this could be modified to show a "visible" character instead.
Explanation:
,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]

    Boilerplate, introducing the characters.

Ford:Listen tothy!

    Input a value to Ajax.

Ajax:You big big cat.

    Set Ford's value to 4 (we will be pushing 4 digits from Ajax onto Ford's personal stack).

Scene V:.Ajax:Remember the remainder of the quotient betweenI twice the sum ofa cat a big big cat.Ford:You be the quotient betweenyou twice the sum ofa cat a big big cat.

    DIGIT-PUSHING LOOP: Push Ajax's last digit onto Ford's stack; divide Ajax by 10.

Ajax:You be the sum ofyou a pig.Be you nicer zero?If solet usScene V.

    Decrement Ford; loop until Ford is 0.

Ford:You big big cat.

    Set Ajax's value to 4 (we will pop 3 digits from Ford's stack in the next loop).

[Exit Ajax][Enter Page]Page:Recall.Ford:You be I.

    Pop the top value off Ford's stack, and store that into Page.
    Here, Page will contain 0 if there are no crowns to be drawn,
    and 1 if there are crowns to be drawn.

Scene X:.Page:Recall.Am I nicer zero?If notopen heart.If notlet usScene L.

    DIGIT-DRAWING LOOP: Pop the top value off of Ford's stack and set Ford equal to that value.
    If there are no crowns to be drawn, output Ford's literal value here, and skip the crown-drawing section.

Ford:You big big big big big cat.Speak thy.Am I worse a cat?If soyou zero.

    Draw crown.
    If we are drawing crowns, and Ford contains 0 here, then we are now done drawing crowns, and thus we store 0 into Page.
    (Put in one more "big" for the crown to look like an @ symbol.)

Scene L:.[Exit Page][Enter Ajax]Ford:You be the sum ofyou a pig.Is you nicer a cat?[Exit Ajax][Enter Page]Ford:If solet usScene X.

    Decrement Ajax; loop until Ajax is 1 (i.e. 3 times).

683 bytes

@HelloGoodbye Thank you, I forgot to get rid of some spaces.

Python 2, 53 bytes
Hats off to Arnauld for -22 bytes. Recursion still wins, though.
lambda k:re.sub("1+0","CCC",`k+10000`)[-3:]
import re

Try it online!
Python 2, 51 bytes
This instead implements tsh's recursive method. Saved 2 bytes thanks to ovs.
f=lambda n,p=1000:n/p and'C'+f(n-p,p/10)or`n+p`[1:]

Try it online!

54 bytes by updating the 1st solution the same way as I did with my JS answer. Seems like recursion still wins in Python, though.

@Arnauld Thanks :D. This edit was really  a SGITW

nwellnhof has since pointed out that adding 10000 leads to the more straightforward pattern 1+0. Hence this 53 bytes version.

@Arnauld Thanks ;) That's rather impressive.

Python 2, 52 bytes
lambda n:['%03d'%n,'%3s'%`n`.lstrip('1')[1:]][n>999]

Try it online!

Retina 0.8.2, 41 bytes
\b((.)|..)\b
$#2$*00$&
T`d`_#`(?=....)1+0

Try it online! Uses #s instead of s. Link includes test cases. Explanation:
\b((.)|..)\b
$#2$*00$&

Pad 1- and 2-digit numbers to three digits.
T`d`_#`(?=....)1+0

Change leading 1s of 4-digit numbers to #s and delete the next 0.

Jelly, 19 bytes - 0 = 19
<ȷ¬ȧDi0ɓ⁶ẋ⁹Ḋ;+ȷDḊṫʋ

A full program printing the result using a space character as the crown.
(As a monadic Link a mixed list of integer digits and space characters is yielded)
Try it online! Or see the test-suite.
...maybe a recursive implementation will be shorter.
How?
<ȷ¬ȧDi0ɓ⁶ẋ⁹Ḋ;+ȷDḊṫʋ - Main Link: integer, N    e.g. 1010       or   10
 ȷ                  - literal 1000                  1000            1000
<                   - less than?                    0               1
  ¬                 - logical not                   1               0
    D               - to decimal list               [1,0,1,0]       [1,0]
   ȧ                - logical and                   [1,0,1,0]       0
      0             - literal zero                  0               0
     i              - first index - call this I     2               1  (0 treated as [0] by i)
       ɓ            - new dyadic chain with swapped arguments - i.e. f(N, I)
        ⁶           - literal space character       ' '             ' '
          ⁹         - chain's right argument        2               1
         ẋ          - repeat                        [' ',' ']       [' ']
           Ḋ        - dequeue                       [' ']           []
                  ʋ - last four links as a dyad - i.e. f(N, I)
             +ȷ     -   add 1000                    2010            1010
               D    -   to decimal list             [2,0,1,0]       [1,0,1,0]
                Ḋ   -   dequeue                     [0,1,0]         [0,1,0]
                 ṫ  -   tail from index (I)         [1,0]           [0,1,0]
            ;       - concatenate                   [' ',1,0]       [0,1,0]
                    - implicit print                " 10"           "010"

Python 2, 40 bytes
lambda n:'%3s'%`10000+n`.lstrip('1')[1:]

Try it online!
Implements an idea similar to Mr. Xcoder's regex-based answer but without a regex. We remove leading 1's in 10000+n as well as the next character, then pad with spaces to length 3. The result is similar to ovs's solution using lstrip but without needing two cases.

Clean, 87 bytes
Doesn't output crowns (uses c).
import StdEnv,Text
$n#i=3-n/1000-n/1100-n/1110
=("ccc"+lpad(""<+n rem(10^i))i'0')%(i,9)

Try it online!
$ n                   // function $ of `n`
 # i =                // define `i` as (the number of digits that aren't crowns)
  3 -                 // three minus
  n / 1000 -          // 1 if first digit is crown
  n / 1100 -          // 1 if second digit is crown
  n / 1110            // 1 if third digit is crown
 = (                  // the string formed by
  "ccc" +             // prefixing three crowns to
  lpad (              // the padding of
   "" <+ n rem (10^i) // non-crown digits of `n`
  ) i '0'             // with zeroes
 ) % (i, 9)           // and removing the extra crowns

Clean, 99 - 3 = 96 bytes
This one has crowns.
import StdEnv,Text
$n#i=3-n/1000-n/1100-n/1110
=(""+lpad(""<+n rem(10^i))i'0')%(i*4,99)

Try it online!

The second answer has a score of only 90.

C,  84  58 bytes
Thanks to @tsh for saving 25 bytes and thanks to @ceilingcat for saving a byte!
f(n,p){for(p=1e3;p/=10;)n-=putchar(n/p>9?46:48+n/p)%12*p;}

Try it online!

f(n,p){for(p=1000;p/=10;)n-=putchar(n/p>9?46:48+n/p)%12*p;}

Japt, 20 bytes
A naïve (and slightly drunk!) port of Arnauld's solution. Uses " for crown.
U+A³ s r"^21*0"_çQÃÅ

Try it

Java 10, 84 83 bytes
n->{for(int p=100,t;p>0;n-=t%12*p,p/=10)System.out.printf("%c",t=n/p>9?46:48+n/p);}

Port of @tsh' C comment.
Uses . instead of crowns.
Try it online.
Alternative approach (84 (87-3) bytes):
n->f(n,1000)String f(int n,int p){return n<p?(n+p+"").substring(1):""+f(n-p,p/10);}

Port of @tsh' JavaScript's answer.
Try it online.

APL (Dyalog Unicode), 32 bytes
1e3∘{⍵<⍺:1↓⍕⍵+⍺⋄'C',(⍵-⍺)∇⍨⍺÷10}

Try it online!
Prefix direct function.
Port of @tsh's JS Answer.
How:
1e3∘{⍵<⍺:1↓⍕⍵+⍺⋄'C',(⍵-⍺)∇⍨⍺÷10} ⍝ Main function, arguments ⍵ and ⍺ (⍵ → input, ⍺ → 1000).
     ⍵<⍺:                          ⍝ If ⍵<⍺
         1↓                        ⍝ Drop (↓) the first element (1) of
           ⍕                       ⍝ Format (⍕); 'stringify'
            ⍵+⍺                    ⍝ ⍵+⍺
               ⋄                   ⍝ else
                'C',               ⍝ Concatenate (,) the literal 'C' with
                         ∇⍨        ⍝ Recursive call (∇) with swapped arguments (⍨)
                    (⍵-⍺)  ⍺÷10    ⍝ New arguments; ⍵ → ⍵-⍺; ⍺ → ⍺÷10

PHP, 71 bytes
for($n=$argn,$x=1e4;1<$x/=10;$n%=$n<$x?$x/10:$x)echo$n<$x?$n/$x*10|0:C;

prints C for the crown. Run as pipe with -nR or try it online.

Haskell, 48 bytes
('2'#).show.(+1000)
n#(a:x)|n==a='c':'1'#x|1>0=x

Try it online!

Perl 6, 38 - 9 = 29 bytes
-2 bytes thanks to Jo King
{~m/...$/}o{S/1+0//}o*+1e4

Try it online!
Inspired by Arnauld's JavaScript solution.

sed, 39
48 bytes, but score is 39, since each  counts as 1.
/..../s/^1+0//
s/^/00/
s/.*(...)/\1/

Try it online!

Pip, 21 bytes
(a+t*mR`1+0`'xX3)@>-3

Try it online!

Stax, 15 bytes
çi╖@u;╟w☼7ø4σcH

Run and debug it
Same idea as Arnauld's answer.


text:
Overlapping Polyglots
Unlike many C&R challenges, this does not require a separate robbers post; the goal of the robbers is to crack the previous answer and then post a new one as a cop.
As answerers, you will write a series of polyglots that look like this (each column is a language, and each entry is the output of the answer in that language):
Language:  1  2  3  4  5  6  7  8  ...
Answer 1:  0  1  2
Answer 2:     1  2  3
Answer 3:        2  3  4
Answer 4:           3  4  5
Answer 5:              4  5  6
Answer 6:                 5  6  7
...

(blank spaces mean that no behavior is required in that case).
Each answer should work in 3 languages and print 3 different consecutive numbers which are each one more than the numbers printed by the previous answer (the first answer prints 0, 1, and 2). Each answer uses two languages from the previous submission, and a third new language. The answerer should try to obfuscate what this third language is.
To post a new answer, you should:

Crack the most recent answer by finding what its third language is.
Preferably, add an explanation for your crack and notify the poster of the answer. Once your submission has been cracked, you should preferably add an explanation as well.
Write a polyglot consisting of this answer's second and third languages, along with another language of your choice. Reveal your first two languages, but do not reveal your new one. It will be the next poster's goal to find this language (or any other language in which it works), so you should try to obfuscate it.

Specifications

The criteria for a valid programming language are the same as those of The Programming Language Quiz, Mark II - Cops:

It has an English Wikipedia article, an esolangs article or a Rosetta Code article at the time this challenge was posted, or is on Try It Online!. Having an interpreter linked in any of these pages makes that interpreter completely legal.
It must satisfy our rules on what constitutes a programming language.
It must have a free interpreter (as in beer). Free here means that anyone can use the program without having to pay to do so.

Each answer must run in less than a minute on a reasonable PC.
You can reuse programming languages, but there must be at least two answers in between (so an individual answer cannot reuse a language).
Cracking a submission consists of finding any programming language that prints the correct result, not just the intended one. If a submission is run in any language that was not declared or found to work, there are no requirements to do anything.
You may not post twice (or more) in a row.

Winning Criterion
The winning answer is whichever answer took to most time to be cracked. The challenge will  never end, so it is always possible for the winning answer to change.

Sandbox.

Opened a chatroom for discussion about possible cracks and building polyglots.

Can the answer output other things apart from the desired number?

Must the answer run in a specific amount of time?

@NieDzejkob No, the program should only output the number, and yes, I'd prefer if the programs ran in under a minute.

@EsolangingFruit What about leading and trailing whitespace? In particular, what about a since trailing newline?

Here's a SEDE query that calculates the amount of time the answers stayed safe (in hours).

@NieDzejkob Thanks! I was considering creating something like that but I'm no good with SEDE.

Can we require that a program must be run with a particular command-line option or compiler flag or argument?

Also, does the output have to only contain the number and nothing else, and can the output to be stdout?

@EmbodimentofIgnorance Yes, you can require command-line flags as they essentially define separate interpreters, and yes, the program must print only the number. The program may output to STDERR, but only the output to STDOUT is relevant.

Hexagony, Klein (101) and ???
  xx={puts/}
gets87!@xx=p

main\

>9.*5,6v

This prints 7 in Hexagony, 8 in Klein (101), and 9 in ???.
The 9 does not work if a newline is added at the end of the code. Be careful if you're testing locally.
Edit: Being live for 20 hours is already a record, so I'll give some hints from now on. (Also because the language in question is IMO not yet well-known.)
Hints

"The 9 does not work if a newline is added at the end" is very significant, as well as the first two spaces (which are ignored by both Hexagony and Klein).
The language is on TIO.
The first two spaces make the program jump to the last line. (It's not a 2D language.)
There's no explicit output command, and the v command ends the program.

Explanation (cracked post)
In the source code
abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@

The relevant instructions in Klein (101) are:
IP->.....................^...........IP->/
.........................|...................
.........................8
.........................\<-.............IP<-
                         @

Klein is fungelike 2D language where crossing the boundary of code area (which is a square) depends on the Klein topology. / and \ are mirrors.
The IP starts at upper left corner facing right. It meets a mirror towards the top boundary, and re-enters the code area on the right side as shown above. Then it hits the mirror again, 8 is pushed, and then (after passing through the boundary several times) stops at @. Then the content of the stack is printed to stdout, which is single 8.

cracked

Befunge-96, Hexagony and ???
abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@

This prints 6 in Befunge-96, 7 in hexagony and 8 in ???.
Explanation
The hexagony code, when "prettified" is:
       a b c d = { } -
      - a g a f f e a v
     o i d i n g t a c t
    i c i n C + + a b c d
   [ f a l s e ] = 1 + 2 +
  3 + 4 + 5 + 6 + 7 + 8 + 9
 + 1 0 + 1 1 + 1 2 + 1 3 + 1
7 ! p r i n t ( a b c d [ 0 >
 1 + 2 + 3 a n d 4 + 5 + 6 <
  0 - 0 ] / / 3 5 ) i f 0 >
   1 t h e n a . n e x t =
    ' ; ' e n d > 1 + 6 .
     @ . . . . . . . . .
      . . . . . . . . .
       . . . . . . . .

The path of execution begins in the top left heading East. The top row doesn't do much. - changes the current memory edge so the value in it is 0. Execution continues heading east on the middle row where 7! loads 7 in the current memory edge and prints is as an integer. [ changes the instruction pointer to North East starting back at 7. After 7+3, execution then reaches [ which changes the instruction pointer to North West starting in the South East corner. Finally the path is ..@ where @ terminates the program.

Cracked.

Trigger, JavaScript and ???
[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52

Prints 11 in Trigger, 12 in JavaScript, and 13 in REDACTED.
Since this has not been cracked for longer than any other answer so far, here are some hints:

In case you didn't notice, the Т and е on the first line are multibyte characters.
[ // and \\ ][ // are no-ops.
The second line, as well as -²52, is dead code.
The language does not have a concept of termination, so ²6 forms an infinite loop.
To be specific, the second byte of the UTF-8 encoding of ², together with the 6, forms an infinite loop.
The number being outputted is encoded by the /!'!/
The language is not on Try It Online, Rosetta Code or Esolangs.
The only available form of output is a 1bpp screen.
The screen's aspect ratio is 2.
While the language was not originally intended as machine code, FPGA implementations do exist.
According to Wikipedia, the intended purpose of the language were video games.
The only way to access the screen is a special instruction, that takes coordinates in selectable registers, and the height as an immediate, and XORs an 8 by n bitmap onto the screen. To make collision detection easier, as well as make it possible to clear the screen, one of the registers will be set when any pixel gets set back to off.

Explanation
Well, this took some time to get cracked. Let's see how the code looks:
0200 5b20    SE VB, V2   ; Skip the next instruction if VB = V2. Since all
0202 2f2f    CALL 0xF2F  ; registers start at 0, this call will be skipped. This
                         ; hides the bytecode from JavaScript.
0204 61d0    LD V1, 0xD0 ; A useless load. Necessary to use a UTF-8 continuation
0206 a22f    LD I, 0x22F ; byte as an instruction and load the address of
                         ; the sprite.
0208 5c5c    SE VC, V5   ; A red herring supposed to suggest symmetry is
                         ; important, as well as a totally intended eliminator
                         ; of inaccurate implementations. Most documentation
                         ; claims that the lowest nibble must be zero, but in
                         ; the original COSMAC VIP implementation it's
                         ; a don't-care.

This means that, while many available emulators behave correctly, the by-the-rules implementation is linked to in the second sentence of the Wikipedia page. Of course, it can't be run directly on an average PC, but I've found the Emma 02 emulator linked to on the COSMAC VIP page to work the best.
020A 205d    CALL 0x05D    ; Skipped.
020C 5b20    SE VB, V2     ; Same as with the very beginning. Red herring.
020E 2f2f    CALL 0xF2F
0210 d0b5    DRW V0, VB, 5 ; Draw the sprite pointed to by I. Since V0 and VB
                           ; haven't been written to yet, the sprite will be drawn
                           ; in the top-left corner of the screen. The height is
                           ; an immediate.
0212 2236    CALL 0x236    ; Jump over the JavaScript and Trigger code. It doesn't
                           ; matter that we never return.
0214-022E *never used*
022F 2f      DB %00101111  ; Sprite data.
0230 21      DB %00100001
0231 27      DB %00100111
0232 21      DB %00100001
0233 2f      DB %00101111
0234-0235 *never used*
0236 b236    JP V0, 0x236  ; Since V0 is still zero, this is an infinite loop.
0238-023C *never used*     ; Together with the previous two lines, it's the
                           ; -²6-²52. It's a red herring supposed to suggest
                           ; prefix, or Polish, notation.

Don't tell me this is machine code on some processor.

@Blacksilver I've been assuming so since two hints ago - what else would look like this, not be on Esolang, but still be notable enough for Wikipedia?

@Blacksilver OK.

@ngm sorry, but no

cracked, I believe, according to the rules.

Python 2, Python 3, ???
a={1,2}
print(1+#a
--bool(1/2)
)

This prints 1 in Python 2, 2 in Python 3, and 3 in ???.
Crack explanation (Cracked post):
#define print(A) main(){puts("0");}
print(1+bool(1/2))

0: C: The first line defines a function-like macro print that ignores its single argument and evaluates to main(){puts("0");}, a full program that prints 0 and exits. The whole expression 1+bool(1/2) is ignored when the print( ) macro on the second line is expanded to main(){puts("0");}.

1: Python 2: The first line is a comment. 1/2 uses integer division in Python 2, giving 0. This value is then interpreted as a boolean (bool(0) -> False) and then added to 1 (1+False -> 1), and then printed.

2: Python 3: The first line is a comment. 1/2 uses float division in Python 3, giving 0.5. This value is then interpreted as a boolean (bool(0.5) -> True) and then added to 1 (1+True -> 2), and then printed.

+1 and Cracked

Lua, brainfuck, ???
abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+14
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
Prints 3 in Lua, 4 in brainfuck and 5 in ???.
Explanation for cracked post:
a=1+2+3+3+4+5+6+7+8+9
b=1+1+1
f=3--(-1)
c=7+9+13+11+12+3--1
g=a+b+c+1+2+3+4+5
j=9+7+g+c+b+a+g+g+g+g+g+g+1+2+3+4+1+1
h=1+1+1+1+333+1+1+1+111+1+1+1+333+1+1+1+1+1.
print(f)

In Python 3, 3--(-1) is 2, so print(f) prints 2 (the other stuff is unnecessary)
In Lua, -- again is a comment, so 3--(-1) is just 3, so print(f) prints 3 (other stuff is again unnecessary)
In brainfuck, there are 57 plusses and 5 minuses setting the first cell on the tape to 52, and the . outputs character 52 which is 4.

+1 and Cracked

JavaScript, CHIP-8, and ???
[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345

12 in JavaScript, 13 in CHIP-8, and 14 in ???
I'm going to go out on a limb and call this one cracked, although I can't quite get it to work I'm sure of the language (which seems to be what the rules ask for.)
Here is an imperfect explanation of the cracked post
The code in hexadecimal "is" (I might be slightly off):
[ 0x5b, 0x20, 0x2f, 0x2f, 0x61, 0xD0, 0xA2, 0x2f, 0x5c,
0x5c, 0x20, 0x5d, 0x5b, 0x20, 0x2f, 0x2f, 0xD0, 0xB5,
0x22, 0x36, 0x0a, 0x63, 0x6f, 0x6e, 0x73, 0x6f,
0x6c, 0x65, 0x2e, 0x6c, 0x6f, 0x67, 0x28, 0x31,
0x31, 0x31, 0x2d, 0x31, 0x31, 0x31, 0x2b, 0x31,
0x32, 0x29, 0x5d, 0x0a, 0x2f, 0x2f, 0x21, 0x27,
0x21, 0x2f, 0x2d, 0xb2, 0x36, 0x2d, 0xb2, 0x35, 0x32 ]

You can go here, click "Binary Tools" and paste this into the byte array box. Click "Decompile".
The key elements of the code are: instructions to say where the "number" is, the sprite command that prints the number, the correct amount of junk here and there, and the following:
: label-0
    0x2F
    0x21
    0x27
    0x21
    0x2F

To see what this represents you can click "Sprite Editor" and paste these hexadecimals into the box underneath. You'll see the answer:

I'm pretty sure you can then put anything you like at the end and the CHIP-8 result will not change, hence the new entry.
I would be delighted if someone could get this fully working, rather than the "proof" of the answer I've given here.

I'm gonna allow that. I'll edit in an explanation later today. Good job.

Cracked

Also, your hexadecimal must be wrong since it does not decode as valid UTF-8...

C, Python 2, ???
#define print(A) main(){puts("0");}
print(1+bool(1/2))

This prints 0 in C, 1 in Python 2, and 2 in ???.
This will be extremely easy to crack for people who know Python, but I wanted a starting-off point for other answers. Subsequent answers should try to obfuscate the third language (I did not do this).

Cracked. Great challenge btw!

Python 3, Lua, ???
a=1+2+3+3+4+5+6+7+8+9
b=1+1+1
f=3--(-1)
c=7+9+13+11+12+3--1
g=a+b+c+1+2+3+4+5
j=9+7+g+c+b+a+g+g+g+g+g+g+1+2+3+4+1+1
h=1+1+1+1+333+1+1+1+111+1+1+1+333+1+1+1+1+1.
print(f)

Prints 2 in Python 3, 3 in Lua and 4 in ???.
Explanation for cracked post:
a={1,2}
print(1+#a
--bool(1/2)
)

In Lua, -- is a comment.  In Python 2 and 3, -- indicates double negative in arithmetic.
In Python 2 and 3, # is a comment.  In Lua, # is the length operator.
In Python 2, 1/2 is floor division, so it evaluates to zero.  In Python 3 this is not the case.  Because both versions of Python evaluate 0 to False, bool(1/2) evaluates to False in Python 2 and True in Python 3.  When used in arithmetic, False is cast to 0 and True is cast to 1.

Cracked

Beatnik, Rust, ???
fn avreg(){}
fn/*azxzzz avreg k zqyzzz ax quke
>>P0 ++puts++puts[pov]
\@�{>*}++puts++puts++puts++puts++puts++puts++puts++puts%
*/main(){print!("17")}

This prints 16 in Beatnik, 17 in Rust, and 18 in ???.
The � character on line 4 should be replaced with ASCII character 18 (this was not done in the TIO links since it's not relevant to either of them).
Explanation (cracked):
The previous answer's language was Rust: specifically, Rust compiled with mrustc. mrustc is an experimental compiler, and as it is mostly intended for bootstrapping a valid version of rustc, it ignores borrow checking and mutability checking, allowing @NieDzejkob's snippet to compile without errors.
This program will work with the normal Rust compiler, so you don't need to install mrustc to test it.
Hints
Since this answer has now gone the longest without being cracked, I'll leave a hint, and continue to do so regularly until it is cracked:

The secret language is two-dimensional and can be found on the Esolang wiki page for two-dimensional languages.
As I mentioned in the comments, the language is not on TIO.
The � character is a red herring and has very little significance. Most bytes can be substituted in its place and the program will still work.

While throwing languages at this at random (having not found much searching for "ascii codepoint 0x12 esolang"), I noticed that it actually outputs 15 in ><>, so that's neat

It would appear that this doesn't print 18 in any language on TIO (without any header, footer, or command-line flags added at least). I do hope I didn't miss any, because it seems like it will probably be quite a bit harder to check through everything on esolangs, Wikipedia, and Rosetta Code... My best guess is that this is some sort of 2D language where either @, P, {, or m starts a character literal and something afterwards prints its codepoint in decimal, but that doesn't explain all of the ++s...

@UnrelatedString Yes, I will confirm that it isn't a language on TIO.

Well, I might have wasted a day going through 100 languages on esolang.org trying to find one that fits... Then I read the ASCII 18 character thing and realized my approach was completely wrong as I searched for a totally different class of languages...

@IQuick143 herrings are red

I would like to wager that the ten occurrences of "puts" are also red herrings, in that they only serve as padding.

@Cloudy7 Removing each occurrence of puts would break the program. Replacing each occurrence of puts with four spaces would also break the program. However, three of the characters in puts are red herrings.

@EsolangingFruit That was going to be my second guess, that one of the characters was a command. Thus I will wager that the answer you are looking for is a BF-derivative.

@Cloudy7 Reasonable guess.

By "the Esolang wiki page for two-dimensional languages", do you mean the category, or some other page?

@PkmnQ The category page.

I counted 16 pluses, but 4 are on a different line. I think it's not brainfuck based, unless something more is at play here.

@PkmnQ Isn't the whole appeal of 2D languages that you can execute the same sequence of instructions in multiple directions?

Cardinal's the best match I know of, but it's unfortunately on TIO.

@Esolanging Fruit I'm willing to guess that the program ends on line 3.

@PkmnQ Ignore my previous (now deleted) comment- the program ends on the last line in the hidden language.

@Esolanging Fruit Oh, okay. I was imagining the s command squared the current cell, so ++s++s turns the current cell into 36, and [ halves it, then o would end the program and implicitly output the current cell.

@PkmnQ None of those commands do what you think they do (except o is used for output).

><>, Befunge-96 and ???
abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+6.@

This prints 5 in ><>, 6 in Befunge-96 and 7 in ???.
I know the intended solution was Befunge-93, but I couldn't resist.
Explanation:
Befunge-96 follows the same path as ><>, but ignores unknown instructions, ending up adding one to the 5 and multiplying it by 9 to get 54, the ascii code for 6.

cracked

Klein (100), Commentator, ???
/@++++2345
start:
program:
 db 'function',10
 add program,program
 jp null+$8
 sbc rbp,rbp
 jnz program
 jr program
 add start
 halt
ex:

Outputs 14 in Klein (100), 15 in Commentator, 16 in ???.
I'm seriously bad at obfuscating polyglots.
Explanation (Cracked post)
 %/    <#> 13
        14
 +   15

In Commentator, common comment tokens and spaces are the important commands, and any other characters are ignored.

Space increments the current memory cell.
<# does XOR 1 on the current memory cell.
% is used to reset the current memory cell to zero.

Wait, there are 16 spaces after %, what happened?
It's actually a small bug (or feature?) in the interpreter. / is treated as the start of a 2-char command, so the space after it is consumed. But /<space> is undefined command (thus a no-op), so the space is effectively skipped.

cracked

Commentator, Beatnik, ???
// k... nak... naKaka pagpAbaGaBag
static answer: Option<&String> = None;

fn llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(s: &String){
  answer = Some(s);
}

fn pneumonoultramicroscopicsilicovolcanoconiosis(){
  println!("{}", answer.unwrap());
}

fn main(){
  let s = String::from("17");
  let t = "Hi! I am a cat. AOOOWRRRWWW! Me need Whiskas! Noow! Mee hungry hast bekommen. Feedme! sudo !!. Sad... six cable hostage wire cable diediediediee #               */";
  llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(&s);
  pneumonoultramicroscopicsilicovolcanoconiosis();
}

Outputs 15 in Commentator, 16 in Beatnik, and 17 in the hopefully one language you are supposed to find.
Okay, it's clue time:

The name of the language refers to a compound of two elements, both of which make up your body, but with wildly varying percentages (which way depending on whether you're a robot).
The language itself is on TIO, but the implementation isn't.
Oh come on.

Looks like Rust( fn main(), among other things), but it doesn't actually run in Rust (explicit lifetime required in the type of 's'), neither on TIO nor another interpreter I found. And I can't find any other language that uses fn as a function identifier.

Huh, even the hint looks like Rust, which is a compound of Fe and O. I can't think of anything else. Maybe different compiler versions?

I suspect this might be Rust compiled with mrustc, which is basically Rust without the borrow checker.

@EsolangingFruit try it

Three months later, I finally got around to cracking this

Brainfuck, ><>, and ???
abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+14
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+9*,@

Prints 4 in Brainfuck, 5 in ><>, and 6 in ???

In brainfuck, nothing changes.
In ><>, v redirects the flow of the program downwards. The n is numeric output. ; ends execution.

Cracked

Klein (101), Z80Golf, ???
!!8@e6v+4>9 \
Almost everything you can find on the internet is true
~Albert Einstein
 ~HUMAN IMAGE MACROS

Prints 8 in Klein (101), 9 in Z80Golf, and 10 in ???.

Cracked by Bubbler

Z80Golf, Somme, ???
!!8@e6v+4>9 \
1((111+111)/111)
00
~tz

This prints 9 in Z80Golf, 10 in Somme and 11 in ???.
Credit to Bubbler for cracking the previous post as Somme, which takes the column sum as the instructions. The first three columns evaluate to
A.;

Which pushes 10, prints it and exits.

Somme, Trigger and ???
[,,E,D,,$,H,_,K,,$,,_,F,L]=!
[]+[]+!![]+[][111]
_=[111][F+L+E+E];[,J,,A,I,,B,C,S]=
[]+_;$=A+B+C+D+I+H+J+A+I+B+H
R=_[$](H+K+I+J+H+C+S+H+B+B+I)();G=($[$]+[])[14]
R[A+B+C+D+B+E+K][E+B+G](12);`
iP<`

This prints 10 in Somme, 11 in Trigger, and 12 in ???.
Since the last two languages are easy to polyglot, I decided to mix that language in.
Explanation (cracked post)
Trigger sees the whole code as a series of tokens (tokenization is greedy):

Single byte (denote A)
Two same bytes followed by a different byte (denote AAB)
Three same bytes (denoted AAA)
Four same bytes (denoted AAAA)

In the source code
!!8@e6v+4>9 \
1((111+111)/111)
00
~tz

the significant tokens are ((1 11+ 111 111, where the first two does nothing and the last two prints 1 each - thus 11.

cracked

CHIP-8, Klein (100), ???
[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345
 %/    <#> 13
       say 14
 + not not 15

Outputs 13 in CHIP-8 (I assume), 14 in Klein, and 15 in ???.
Another Klein topology, tsk tsk. I've preserved the code before the @, since I don't know what will affect CHIP-8.
Clues
I'm kinda overdue for these, sorry. I'll try and add one a day.

Removing the first half (first three lines) of the program still works.
This is not a 2D language
The language is on TIO
The nots and the say can be removed without affecting the program

For reference, the program without that stuff looks like this:
 %/    <#> 13
        14
 +   15

Try it online!

...I'm scared. This runs in Runic and outputs 16.

@Draco18s Intentional

It won't after my next update, as I added some better string handling to several operators (currently TIO pops a 1 and a string that is the made up from first line and goes "this isn't a value" and discards them, the update will concat, even though I have an operator for that, but concat operates on characters and numbers as well as strings, where as + treats them as numbers). But it was super spooky to be like "I wonder what...oh god, this could be left unmodified and be the next entry...if only I knew the ??? language..."

Are you defining half by bytes, characters, lines, or something specific?

I figured the language was on TIO. There are, however, 570 languages on TIO. :p

Cracked.

Rust, BrainSpace, ???
fn v(){}
/*{>*}+++++++++++++++++++++++++[[[%]]]*\
\mop+p+p+pox
*/fn main(){print!("17")}             //print!(19)$f($f(-x++this::id()++x)++x@);"v2"
  //):/
//////////////////////////////////////[]<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

This prints 17 in Rust, 18 in BrainSpace, and 19 in ???.
Crack explanation
Remembered this existed looking through old messages, figured I could scrape Esolangs for every implemented 2D language where the article body has an o surrounded by non-letters, and fortunately couldn't be bothered to filter out languages that are on TIO because it turns out BrainSpace got added to TIO about five months after it was confirmed not on TIO. (It's also fortunate that it was alphabetically the second candidate out of 48.)
For posterity (as comments can be ephemeral), the full sequence of hints given was:

The language is not on TIO. (as of 2019/4/3)
The language is 2D and listed as such on Esolangs.
The ASCII character 18 is a red herring.
s doesn't square, [ doesn't halve, and o doesn't end the program.
o performs output.

BrainSpace is some kind of weird half-Brainfuck-half-fungeoid where {} move the tape head, * is a conditional jump, % is an omnidirectional reflect, all three of pP+ are equivalent increment commands, and all three of oO0 are equivalent output commands. The instruction pointer starts in the top left moving right, so fn avreg(){} sends the pointer down in column 5, {>*} sends it careening into a bunch of increments that it gets bounced through again on the way back then passes it right along to the left, and P0 ++puts++puts[pov] increments 48 to 49, prints that, slaps another 7 on, prints, then terminates the program by leaving the edge--BrainSpace's field is not toroidal.

This should be considerably easier, but you might take some wrong turns.