text:
Print the full conjugation of a French verb
Given a string ending in either "er", "ir", or "re" (the "infinitive"), output the full conjugation of the string as a French verb in the seven simple tenses. For each tense (in the order given below), output each subject pronoun in the following order: je, tu, il, elle, nous, vous, ils, elles; followed by a space, the verb conjugated according to that pronoun, and a newline. If the verb begins with a vowel (aeiou) or h, je becomes j' and the space is omitted.
In all the examples, I will use the regular verbs exister, invertir, and rendre to demonstrate. French has a great many irregular verbs, which we shall ignore to make the specification and challenge easier.
The tenses
Present tense
Remove the er/ir/re from the infinitive and add the following endings:

er: j'existe, tu existes, il existe, elle existe, nous existons, vous existez, ils existent, elles existent.
ir: j'invertis, tu invertis, il invertit, elle invertit, nous invertissons, vous invertissez, ils invertissent.
re: je rends, tu rends, il rend, elle rend (no endings), nous rendons, vous rendez, ils rendent, elles rendent.

Imperfect
Remove the er/ir/re from the infinitive and add the following endings:

er and re: j'existais, tu existais, il existait, elle existait, nous existions, vous existiez, ils existaient, elles existaient.
ir: j'invertissais, tu invertissais, il invertissait, elle invertissait, nous invertissions, vous invertissiez, ils invertissaient.

Simple past
Remove the er/ir/re from the infinitive and add the following endings:

er: j'existai, tu existas, il exista, elle exista, nous existâmes, vous existâtes, ils existèrent, elles existèrent.
ir and re: je rendis, tu rendis, il rendit, elle rendit, nous rendîmes, vous rendîtes, ils rendirent, elles rendirent.

Future
For all verbs, add these endings directly to the infinitive (though re verbs drop the e):

j'invertirai, tu invertiras, il invertira, elle invertira, nous invertirons, vous invertirez, ils invertiront, elles invertiront.

Conditional
For all verbs, add these endings directly to the infinitive (though re verbs drop the e):

j'invertirais, tu invertirais, il invertirait, elle invertirait, nous invertirions, vous invertiriez, ils invertiraient, elles invertiraient*.

Present subjunctive
Remove the er/ir/re from the infinitive and add the following endings:

er and re: j'existe, tu existes, il existe, elle existe, nous existions, vous existiez, ils existent, elles existent.
ir: j'invertisse, tu invertisses, il invertisse, elle invertisse, nous invertissions, vous invertissiez, ils invertissent, elles invertissent.

Imperfect subjunctive
Remove the er/ir/re from the infinitive and add the following endings:

er: j'existasse, tu existasses, il existât, elle existât, nous existassions, vous existassiez, ils existassent, elles existassent.
ir and re: je rendisse, tu rendisses, il rendît, elle rendît, nous rendissions, vous rendissiez, ils rendissent, elles rendissent.

Sample output
For an er verb, aller, your output should be:
j'alle
tu alles
il alle
elle alle
nous allons
vous allez
ils allent
elles allent
j'allais
tu allais
il allait
elle allait
nous allions
vous alliez
ils allaient
elles allaient
j'allai
tu allas
il alla
elle alla
nous allâmes
vous allâtes
ils allèrent
elles allèrent
j'allerai
tu alleras
il allera
elle allera
nous allerons
vous allerez
ils alleront
elles alleront
j'allerais
tu allerais
il allerait
elle allerait
nous allerions
vous alleriez
ils alleraient
elles alleraient
j'alle
tu alles
il alle
elle alle
nous allions
vous alliez
ils allent
elles allent
j'allasse
tu allasses
il allât
elle allât
nous allassions
vous allassiez
ils allassent
elles allassent

For an ir verb, avoir, your output should be:
j'avois
tu avois
il avoit
elle avoit
nous avoissons
vous avoissez
ils avoissent
elles avoissent
j'avoissais
tu avoissais
il avoissait
elle avoissait
nous avoissions
vous avoissiez
ils avoissaient
elles avoissaient
j'avois
tu avois
il avoit
elle avoit
nous avoîmes
vous avoîtes
ils avoirent
elles avoirent
j'avoirai
tu avoiras
il avoira
elle avoira
nous avoirons
vous avoirez
ils avoiront
elles avoiront
j'avoirais
tu avoirais
il avoirait
elle avoirait
nous avoirions
vous avoiriez
ils avoiraient
elles avoiraient
j'avoisse
tu avoisses
il avoisse
elle avoisse
nous avoissions
vous avoissiez
ils avoissent
elles avoissent
j'avoisse
tu avoisses
il avoît
elle avoît
nous avoissions
vous avoissiez
ils avoissent
elles avoissent

For an re verb, faire, your output should be:
je fais
tu fais
il fai
elle fai
nous faions
vous faiez
ils faient
elles faient
je faiais
tu faiais
il faiait
elle faiait
nous faiions
vous faiiez
ils faiaient
elles faiaient
je faiis
tu faiis
il faiit
elle faiit
nous faiîmes
vous faiîtes
ils faiirent
elles faiirent
je fairai
tu fairas
il faira
elle faira
nous fairons
vous fairez
ils fairont
elles fairont
je fairais
tu fairais
il fairait
elle fairait
nous fairions
vous fairiez
ils fairaient
elles fairaient
je faie
tu faies
il faie
elle faie
nous faiions
vous faiiez
ils faient
elles faient
je faiisse
tu faiisses
il faiît
elle faiît
nous faiissions
vous faiissiez
ils faiissent
elles faiissent

(These are not the true conjugations of the above verbs. In reality they are highly irregular.)
This is code golf. The shortest submission wins.

I think using manger, finir and (entre)prendre as example should be better, feels like you intentionally took irregular verbs :)

@jonatjano (entre)prendre is irregular as well. So maybe entendre instead. (But I do agree that the current examples look awful if you happen to know French.)

@Arnauld I happen to BE french and it really hurts :) and yes I forgot (entre)prendre was irregullar entendre is really better

Does y count as a vowel in French / for this challenge?

I echo the previous comments: Please update the test cases to use regular verbs and include a note in the spec that special casing the irregular verbs is beyond the scope of the challenge.

@KevinCruijssen I'll let the OP decide but as a native French speaker, I would definitely say je yoyote rather than j'yoyote (although a few sites do suggest the latter).

@Arnauld Ok, in that case I'd indeed say to exclude it as well. In Dutch the letter y is counted as a vowel in general, but for all Dutch verbs I know of with a leading y it's used as a consonant. I see it's similar for French after a quick Google search, based on these French verbs: yoyoter; youtser; yasser; yodler.

What torture is this? Bad memories of 3rd form French class! :)

@Shaggy It was there from the start: "French has a great many irregular verbs, which we shall ignore to make the specification and challenge easier."

I don't think that @Shaggy was implying that there's a problem with the spec, but rather just a problem with the test cases -- because there's little point in applying regular rules to irregular verbs.

Charcoal, 488 276 bytes
Ｆ⪪§⪪”}∨>↓⁷8lυW!M\ηX↨%]ν÷g×D\﹪3}Þ1Xζ÷Ｓ¹.m×Ｋ⦄}.}◧TI¡νυOＡ×∨´ＴE…8λ→Ｙ×⁶⁰⟦αＬi↓↶⎚⦃ω>◧‴κv≦｜≕…K⊕Yλ⎇＆✳⍘ςθＡ⪪@₂)¦Hg@»‽Ｈ2.⁵÷-⁸n¬u⊘¡″βEＮ≡x↔÷Wyⅈ(Ｊ\`﹪◨⁸｜|kU_ ←%Zσ¤«⊟Ｑ§!χ⁰⸿¤:\`α´↖±↔5À⊗I¡o⊞⁵cp✳ιg«“/_$↖↧↧⪫,↗A”¶¶⌕er§θ±²¶Ｆ⁶Ｆ⎇›№aehiou§θ⁰κ⟦j'⟧⁺⪪§⪪”↶↥ζ⊟pW↔,⦄≡ＷA→÷⪫$Ａⅉ⟦v⎇” κ¶¦ «λ…θ⁻Ｌθ²⭆§⪪ι κ§⁺âèîμ⌕AEIμ⸿

Try it online! Link is to verbose version of code. Explanation:
Ｆ⪪§⪪”...”¶¶⌕er§θ±²¶

A very long compressed string is split into paragraphs, each paragraph representing the endings for a particular verb ending. The appropriate ending is selected depending on the second last letter in the verb. The paragraph is split into lines representing the endings for each tense in turn. The tenses are then looped over.
Ｆ⁶

Loop over the three persons and their plurals.
Ｆ⎇›№aehiou§θ⁰κ⟦j'⟧⁺⪪§⪪”↶↥ζ⊟pW↔,⦄≡ＷA→÷⪫$Ａⅉ⟦v⎇” κ¶¦ «

Loop over the pronouns for those persons (third person has two genders), but special-casing ["j'"] where necessary.
λ

Print the pronoun.
…θ⁻Ｌθ²

Print the verb stem.
⭆§⪪ι κ§⁺âèîμ⌕AEIμ

Print the suffix, but translate AEI to âèî as Charcoal can't compress accented letters.
⸿

Start a new line.

JavaScript (ES6),  507  504 bytes
Returns an array of 7 tenses, where each tense is an array of 8 forms.
(v,[a,b]=v.split(/(..)$/),g=b>'r'?2:b<'i')=>[...S='0123456'].map(x=>'je/tu/il/elle/nous/vous/ils/elles'.split`/`.map((s,n)=>(!n*/^[aehiou]/.test(a)?"j'":s+' ')+a+(x>2&x<5?g>1?'r':b:'')+[...S+'789ABCD'].reduce((p,c)=>(l=p.split(c)).join(l.pop()),'55e91D4D3D7/s//9eC0s00tBai72AA/âm5âtes/èr1/îm5îtes8r72AA9oC/55e8483/7DeDeDeB76e65ât6i46i367DeD5îtB7D8ssCn2s22t848327BDi4Di3DA/a9/4/3/8/i7en6Ass5e/4on3ez2Ai178s88t0Dai').split`/`[(n-=n>2,n-=n>5)+('0x'+'102433656777888A99CBC'[x*3+g])*6]+['sst'[~-n/2]]))

Try it online! (regular verbs)
Try it online! (grammatical disaster using the irregular verbs suggested in the challenge)

Retina, 2051 1891 bytes (UTF-8)
(.+)er$
je $1e0tu $1es0il $1e0elle $1e0nous $1ons0vous $1ez0ils $1ent0elles $1ent0je $1ais0tu $1ais0il $1ait0elle $1ait0nous $1ions0vous $1iez0ils $1aient0elles $1aient0je $1ai0tu $1as0il $1a0elle $1a0nous $1âmes0vous $1âtes0ils $1èrent0elles $1èrent0je $1erai0tu $1eras0il $1era0elle $1era0nous $1erons0vous $1erez0ils $1eront0elles $1eront0je $1erais0tu $1erais0il $1erait0elle $1erait0nous $1erions0vous $1eriez0ils $1eraient0elles $1eraient0je $1e0tu $1es0il $1e0elle $1e0nous $1ions0vous $1iez0ils $1ent0elles $1ent0je $1asse0tu $1asses0il $1ât0elle $1ât0nous $1assions0vous $1assiez0ils $1assent0elles $1assent
(.+i)r$
je $1s0tu $1s0il $1t0elle $1t0nous $1ssons0vous $1ssez0ils $1ssent0elles $1ssent0je $1ssais0tu $1ssais0il $1ssait0elle $1ssait0nous $1ssions0vous $1ssiez0ils $1ssaient0elles $1ssaient0je $1s0tu $1s0il $1t0elle $1t0nous avoîmes0vous avoîtes0ils $1rent0elles $1rent0je $1rai0tu $1ras0il $1ra0elle $1ra0nous $1rons0vous $1rez0ils $1ront0elles $1ront0je $1rais0tu $1rais0il $1rait0elle $1rait0nous $1rions0vous $1riez0ils $1raient0elles $1raient0je $1sse0tu $1sses0il $1sse0elle $1sse0nous $1ssions0vous $1ssiez0ils $1ssent0elles $1ssent0je $1sse0tu $1sses0il avoît0elle avoît0nous $1ssions0vous $1ssiez0ils $1ssent0elles $1ssent
(.+)re$
je $1s0tu $1s0il fai0elle fai0nous $1ons0vous $1ez0ils $1ent0elles $1ent0je $1ais0tu $1ais0il $1ait0elle $1ait0nous $1ions0vous $1iez0ils $1aient0elles $1aient0je $1is0tu $1is0il $1it0elle $1it0nous $1îmes0vous $1îtes0ils $1irent0elles $1irent0je $1rai0tu $1ras0il $1ra0elle $1ra0nous $1rons0vous $1rez0ils $1ront0elles $1ront0je $1rais0tu $1rais0il $1rait0elle $1rait0nous $1rions0vous $1riez0ils $1raient0elles $1raient0je $1e0tu $1es0il $1e0elle $1e0nous $1ions0vous $1iez0ils $1ent0elles $1ent0je $1isse0tu $1isses0il $1ît0elle $1ît0nous $1issions0vous $1issiez0ils $1issent0elles $1issent
je ([aeiouh].+)
j'$1
S`0

To the point implementation. Will try to golf it down from here.
Try it online.
Explanation:
Handle all words ending with er, with a 0 as line separator:
(.+)er$
je $1e0tu $1es0il $1e0elle $1e0nous $1ons0vous $1ez0ils $1ent0elles $1ent0je $1ais0tu $1ais0il $1ait0elle $1ait0nous $1ions0vous $1iez0ils $1aient0elles $1aient0je $1ai0tu $1as0il $1a0elle $1a0nous $1âmes0vous $1âtes0ils $1èrent0elles $1èrent0je $1erai0tu $1eras0il $1era0elle $1era0nous $1erons0vous $1erez0ils $1eront0elles $1eront0je $1erais0tu $1erais0il $1erait0elle $1erait0nous $1erions0vous $1eriez0ils $1eraient0elles $1eraient0je $1e0tu $1es0il $1e0elle $1e0nous $1ions0vous $1iez0ils $1ent0elles $1ent0je $1asse0tu $1asses0il $1ât0elle $1ât0nous $1assions0vous $1assiez0ils $1assent0elles $1assent

Handle all words ending with ir, with 0 as line separator:
(.+i)r$
je $1s0tu $1s0il $1t0elle $1t0nous $1ssons0vous $1ssez0ils $1ssent0elles $1ssent0je $1ssais0tu $1ssais0il $1ssait0elle $1ssait0nous $1ssions0vous $1ssiez0ils $1ssaient0elles $1ssaient0je $1s0tu $1s0il $1t0elle $1t0nous avoîmes0vous avoîtes0ils $1rent0elles $1rent0je $1rai0tu $1ras0il $1ra0elle $1ra0nous $1rons0vous $1rez0ils $1ront0elles $1ront0je $1rais0tu $1rais0il $1rait0elle $1rait0nous $1rions0vous $1riez0ils $1raient0elles $1raient0je $1sse0tu $1sses0il $1sse0elle $1sse0nous $1ssions0vous $1ssiez0ils $1ssent0elles $1ssent0je $1sse0tu $1sses0il avoît0elle avoît0nous $1ssions0vous $1ssiez0ils $1ssent0elles $1ssent

Handle all words ending with re, with 0 as line separator:
(.+)re$
je $1s0tu $1s0il fai0elle fai0nous $1ons0vous $1ez0ils $1ent0elles $1ent0je $1ais0tu $1ais0il $1ait0elle $1ait0nous $1ions0vous $1iez0ils $1aient0elles $1aient0je $1is0tu $1is0il $1it0elle $1it0nous $1îmes0vous $1îtes0ils $1irent0elles $1irent0je $1rai0tu $1ras0il $1ra0elle $1ra0nous $1rons0vous $1rez0ils $1ront0elles $1ront0je $1rais0tu $1rais0il $1rait0elle $1rait0nous $1rions0vous $1riez0ils $1raient0elles $1raient0je $1e0tu $1es0il $1e0elle $1e0nous $1ions0vous $1iez0ils $1ent0elles $1ent0je $1isse0tu $1isses0il $1ît0elle $1ît0nous $1issions0vous $1issiez0ils $1issent0elles $1issent

Replace all je  followed by a vowel or 'h' with j':
je ([aeiouh].+)
j'$1

And finally split on zeroes, which basically replaces all 0s with newlines:
S`0

After which the result is output implicitly.


text:
Farkle Fest 2k19: An AI dice game tournament
Farkle Fest 2k19
In this challenge, we will be playing the semi-popular dice game Farkle.
Farkle is a dice game that has players selecting to save dice or risk rerolling the die for more points to add to their total. Players should use probability, game-state considerations and opponent tendency to make their decisions.
How to play
Rules lifted from this PDF, which includes scoring. There are some differences that you should note after

Each player takes turns rolling the dice. When it's your turn, you
  roll all six dice at the same time. Points are earned every time you
  roll a 1 or 5, three of a kind, three pairs, a six-dice straight
  (1,2,3,4,5,6), or two triplets.
If none of your dice earned points, that's a Farkle! Since you earned
  no points, you pass the dice to the next player.
If you rolled at least one scoring die, you can bank your points and
  pass the dice to the next player, or risk the points you just earned
  during this round by putting some or all of the winning die (dice)
  aside and rolling the remaining dice. The remaining dice may earn you
  additional points, but if you Farkle, you lose everything you earned
  during the round.
If all of your dice contribute to the score you re-roll
  the dice and add to the points already rolled, but a farkle will lose all the points, including rollover. This is called a "hot-streak"
Scoring is based only on the dice in each roll. You can earn points
  by combining dice from different rolls. You can continue rolling the
  dice until you either Pass or Farkle. Then the next player rolls the
  six dice until they Pass or Farkle. Play continues until it is your
  turn again.
The final round starts as soon as any player reaches 20,000 or more
  points.
Scoring:
    five = 50
    one = 100
    triple 1 = 1000
    triple 2 = 200
    triple 3 = 300
    triple 4 = 400
    triple 5 = 500
    triple 6 = 600
    one thru six = 1500
    three pairs = 1500
    two triplets = 2500
    four of a kind = 1000
    five of a kind = 2000
    six of a kind = 3000
    farkle = 0
    three farkles in a row = -1000

Notes:

There are varying scoring tables. Use the one linked and rewritten above
Most online versions say something like "You cannot earn points by combining dice from different rolls". This is not how I play. If you roll triple sixes and reroll and end up with another six you now have quad sixes.
The ending score has been increased from 10,000 to 20,000. This increases the decision points and decreases randomness.
Some variants have a "threshold to start getting points" (often around 500). This would prevent you from keeping a roll of less than 500 if your score was 0 (or negative). This rule is not in effect.

Challenge
In this challenge, you will write a Python 3 program to play a three player, winner takes all glory game of Farkle
Your program will receive the state of the game, which contains:

    index (where you sit at the table)
    end_score (score required to win (20,000))
    game_scores (all the players current score)
    state_variable (space for you to put whatever you want)

    #round values, these change during the round
    round_score (score of the current set of dice)
    round_rollover (score from previous "hot streaks")
    round_dice (current dice)
    round_set_aside (dice you set aside before rolling)
    round_used_in_score (lets you know which dice are adding to your score)

Players should return an array showing which dice they want to set aside. This should be wrapped in a set_dice_aside(self) method
For instance, here's a player that will save dice that add to their score until the score they would get is 500 or greater
class GoForFiveHundred(Bot):
    def set_dice_aside(self):
        while (self.round_score + self.round_rollover) < 500:
            return self.round_used_in_score
        return [True, True, True, True, True, True]

Gameplay
The tournament runner can be found here: Farkle_Fest_2K19. Run main.py to run a tournament. I'll keep it updated with new submissions. Example programs can be found in farkle_bots.py. Lots of code was lifted from maxb, many thanks for that framework and code.
A tournament consists of 5000 games per 10 players (rounded up, so 14 players means 10,000 games). Each game will be three random players selected from the pool of players to fill the three positions. Players will not be able to be in the game twice.
Scoring
The winner of each game is the player with the most points at the end of the game. In the case of a tie at the end of a game all players with the maximum money amount are awarded a point. The player with the most points at the end of the tournament wins. I will post scores as I run the games.
The players submitted will be added to the pool. I added three dumb bots to start.
Caveats
Do not modify the inputs. Do not attempt to affect the execution of any other program, except via cooperating or defecting. Do not make a sacrificial submission that attempts to recognize another submission and benefit that opponent at its own expense. Standard loopholes are banned.
Limit the time taken by your bot to be ~1s per turn.
Submissions may not duplicate earlier submissions.
If you have any questions, feel free to ask.
Winning
The competition will stay open indefinitely, as new submissions are posted. However, I will declare a winner (accept an answer) based on the results two month after this question was posted (November 2nd).
Simulation of 5000 games between 5 bots completed in 675.7 seconds
    Each game lasted for an average of 15.987000 rounds
    8 games were tied between two or more bots
    0 games ran until the round limit, highest round was 48
+----------------+----+--------+--------+------+------+-------+
|Bot             |Win%|    Wins|  Played|   Max|   Avg|Avg win|
+----------------+----+--------+--------+------+------+-------+
|WaitBot         |95.6|    2894|    3028| 30500| 21988|  22365|
|BruteForceOdds  |38.7|    1148|    2967| 25150| 15157|  20636|
|GoForFiveHundred|19.0|     566|    2981| 24750| 12996|  20757|
|GoForTwoGrand   |13.0|     390|    2997| 25450| 10879|  21352|
|SetAsideAll     | 0.2|       6|    3027| 25200|  7044|  21325|
+----------------+----+--------+--------+------+------+-------+

+----------------+-------+-----+
|Bot             |   Time|Time%|
+----------------+-------+-----+
|BruteForceOdds  |2912.70| 97.0|
|WaitBot         |  58.12|  1.9|
|GoForTwoGrand   |  13.85|  0.5|
|GoForFiveHundred|  10.62|  0.4|
|SetAsideAll     |   7.84|  0.3|
+----------------+-------+-----+

And the results without WaitBot, which I'm still morally undecided on:
+----------------+----+--------+--------+------+------+-------+
|Bot             |Win%|    Wins|  Played|   Max|   Avg|Avg win|
+----------------+----+--------+--------+------+------+-------+
|BruteForceOdds  |72.0|    2698|    3748| 26600| 19522|  20675|
|GoForFiveHundred|37.2|    1378|    3706| 25350| 17340|  20773|
|GoForTwoGrand   |24.3|     927|    3813| 26400| 14143|  21326|
|SetAsideAll     | 0.1|       5|    3733| 21200|  9338|  20620|
+----------------+----+--------+--------+------+------+-------+
+----------------+-------+-----+
|Bot             |   Time|Time%|
+----------------+-------+-----+
|BruteForceOdds  |4792.26| 98.9|
|GoForTwoGrand   |  24.53|  0.5|
|GoForFiveHundred|  18.06|  0.4|
|SetAsideAll     |  13.01|  0.3|
+----------------+-------+-----+

Is it possible to have access to the score function or something like it, so that people don't have to write their own for every submission?

@jo: yes. Triple ones will be 1000, apologies. I will expose that method to the bots, good idea

I don't think you reset the number of farkles in a row when a player doesn't get a farkle

I've only read the rules once, but can a submission interact with others during a game? If not, this would likely be better as a [code-challenge] or something similar.

Do you need to put aside at least one die a round? The controller allows putting aside no dice. Also, can you reintroduce dice you have put aside (also allowed)?

@JoKing: You are correct -- another good catch. I will reset the farkle count upon non-farkle. Your other question is a good one... I think your strategy is valid but I'll do some more research after work. Will respond to your strategy

@someone: You can, but indirectly. If another player is way ahead you can be more aggressive and vis versa. I think that level of interaction makes it valid for this type of competition but if you disagree I can change it

@Tyler Are you sure it's a good idea to allow 1s per turn? You could be bruteforcing stuff (that is, simulating all your possible moves repeatedly and calculating averages or something), and that'd slow down the game to take a few seconds, and you have thousands of them. I am not sure about [koth] here, but I can see code-challenge has some advantages (for example, it's easier and faster to test and debug).

@someone sure let em brute force stuff

Feel free to update the challenge to invalidate WaitBot. I don't really think that that strategy should be valid

BruteForceOdds
Here's that brute force bot:
from main import Controller
from farkle_bots import Bot

scoreDevice = Controller(1, 1, [], 0)

class BruteForceOdds(Bot):
    def set_dice_aside(self):
        stop_score = self.round_score + self.round_rollover
        if self.game_scores[self.index] + stop_score > max(self.game_scores + [self.end_score]):
            # Take the win
            return [True, True, True, True, True, True]

        using = self.round_used_in_score[:]
        if self.round_dice.count(5) < 3:
            for i in range(len(using)):
                if self.round_dice[i] == 5 and not self.round_set_aside[i] and using.count(True) > self.round_set_aside.count(True)+1:
                    using[i] = False
        if self.round_dice.count(1) < 3:
            for i in range(len(using)):
                if self.round_dice[i] == 1 and not self.round_set_aside[i] and using.count(True) > self.round_set_aside.count(True)+1:
                    using[i] = False
        if using.count(True) < 3 and self.round_rollover == 0:
            # Stopping here is basically never a good idea
            return using

        if bruteScore(self.round_dice, using, self.round_rollover) > stop_score:
            return using
        return [True, True, True, True, True, True]

def bruteScore(round_dice, set_aside, base_score):
    base_dice = []
    for i in range(len(round_dice)):
        if(set_aside[i]):
            base_dice.append(round_dice[i])
    totalCount = 0
    totalScore = 0
    for new_dice in allPossibleRolls(len(round_dice) - len(base_dice)):
        dice = base_dice + new_dice
        keep = [True]*len(base_dice)+[False]*len(new_dice)
        farkle, round_score, round_rollover, used_in_score = scoreDevice.score(dice, keep, base_score)
        totalCount += 1
        if not farkle:
            totalScore += round_score + round_rollover
    return totalScore / totalCount

def allPossibleRolls(length):
    if length == 0:
        yield []
        return
    for i in range(1,7):
        for l in allPossibleRolls(length-1):
            yield [i]+l

It only fares slightly better than the example program GoForFiveHundred.
EDIT: Made it a bit smarter.  Now it does noticeably better than any of the example bots.

Amazing! I'll run it against the other bots later today!

@TylerBarron Did you do it? I don't see it in the results listed in the question.

I did later than I hoped. It should have results now! I also may have a few other challengers incoming :)

WaitBot
class WaitBot(Bot):
	def set_dice_aside(self):
		return [self.round_rollover+self.round_score > 5000]*6

Try it online!
This basically takes no dice until the total round score is greater than 5000. Really, it's betting on getting hot streaks before farkles.
This wins about 97% of the time when put up against the default three bots.
Edit: Erm, this may not be valid, since you need to putting some or all of the winning die (dice) aside. I'm waiting on confirmation from the asker on this, since the controller allows it.

I just realised the TIO link you provided is useless without the given classes

source: Stack Exchange

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

sort: votes


text:
First Number to Contain Each Letter
Given a single letter from A to Z (except J and K) as input, output the smallest non-negative integer containing that letter in its written form. Assume numbers never contain the word "and", so 101 is "one hundred one", not "one hundred and one". Assume American (short-scale) counting, so one million is 10^6 and one billion is 10^9.
a 1000                           one thousand
b 1000000000                     one billion
c 1000000000000000000000000000   one octillion
d 100                            one hundred
e 0                              zero
f 4                              four
g 8                              eight
h 3                              three
i 5                              five
j
k
l 11                             eleven
m 1000000                        one million
n 1                              one
o 0                              zero
p 1000000000000000000000000      one septillion
q 1000000000000000               one quadrillion
r 0                              zero
s 6                              six
t 2                              two
u 4                              four
v 5                              five
w 2                              two
x 6                              six
y 20                             twenty
z 0                              zero

J and K are not part of the input specification, so your behavior is undefined for them. Given one of the above letters, output the (decimal) number next to it. You can take input in lowercase or uppercase, but you cannot require that some inputs are lowercase and others uppercase.
This is code-golf, so the shortest answer in bytes wins.

I'm not quite sure why this challenge has been downvoted so much? As far as I can see, it's clear and on-topic. Sure it's most likely to simply be encoding each letter to its corresponding number, but I don't think that justifies 3 downvotes?

didn't downvote, but fwiw even though it's strictly not required, it would have helped for clarity to list the names of the numbers. it's nothing more than a kolmogoriv-complexity / compression problem, but somehow that's not immediately clear from the description.  input domain: a..z.  output: defined by this table.  actual ## sections like that would also help.

@Jonah added, thanks for the feedback

You're saying "one bajillion" isn't a real number?

@JoKing what's it's decimal representation? :)

It would also be interesting with any combination of letters.

@EricDuminil feel free to ask a separate question!

"Googolpleiji" - J - 3^3^9.  "Killillion" - K - 10^(3*10^3000+3) From here.

I reckon that a StackExchange user who thinks that k can't appear in a number's name is rather lakhing in imagination.

@AndrewGrimm well, I don't want Mathematica builtins to be completely useless in a sea of compression answers

@Jonah, Googolpleiji is not the smallest for j : almost there's Googovij, and for k : Integral-dekapetaseptemdecile from the same page

I think Googolpleiji and Killillion might be a little bit challenging to output.

For j the output could be sqrt(-1).

@Jonah "Googovij" (105,413,504) is shorter

Integer Sequence A050933

JavaScript (Node.js),  78 75 74  73 bytes
c=>(n=([x]=Buffer(c+'8>P7 $(#%  +;! MD &"$%"&4 '))[x-96]-53)<0?n+21:10**n

Try it online!
How?
Each value is encoded with a single printable character. We use the ASCII range \$[32..52]\$ to encode \$n-32\$ and the range \$[53..80]\$ to encode \$10^{n-53}\$.
Commented
c =>                                   // c = input character
  ( n =                                //
    ( [x] =                            // let x be the 1st byte of the
        Buffer(                        // buffer made of:
          c +                          //   c followed by
          '8>P7 $(#%  +;! MD &"$%"&4 ' //   the encoded values
        )                              //
    )[x - 96]                          // let n be the encoded value corresponding to c
    - 53                               // minus 53
  ) < 0 ?                              // if n is negative:
    n + 21                             //   return n + 21
  :                                    // else:
    10 ** n                            //   return 10 ** n

Ruby, 65 bytes
->n{i="CI[B?;7<:??4F>?XO?9=;:=9+?"[n.ord-65].ord-64;i>0?10**i:~i}

Try it online!
Improvements inspired by GB's comment.
Ruby, 70 bytes
->n{i="ci}b@DHCE@@KfA@xo@FBDEBFT@"[n.ord-65].ord;i>96?10**(i-96):i-64}

Try it online!

67 bytes

@GB thanks, the idea of having negative values for i was useful. Now down to 65.

Stax, 33 bytes
º░¡µ?Äz*B╥╪╩ΓoΣ4ù↓|♂5%⌡ÿΩ²┼h{☻4O└

Run and debug it
Procedure:

Extract codepoint from input.
Index into constant array [3, 5, 7, 9, 11, -6, 1, 0, -24, -15, 0, 6, 2, 4, 5, 2, 6, 20, 0, -3, -9, -27, -2, 0, 4, 8] using codepoint. (with wrap-around)
If the result is negative, negate and raise 10 to that power, otherwise leave as-is.

///, 125 bytes
/:/\/\///T/000:d/100:a/d0:m/aT:b/aTT:q/bTT:p/qTTT:c/pT:e/0:f/4:g/8:h/3:i/5:l/11:n/1:o/0:r/0:s/6:t/2:u/4:v/5:w/2:x/6:y/20:z/0/

Try it online!
Input is appended to the end of the code, as per I/O meta. The footer in the above TIO link tests all letters simultaneously, as a single newline-delimited string, but the code also works just fine when inputting a single character.

Wolfram Language (Mathematica), 50 bytes
Letters b, c, m, p and q are skipped for performance reasons when testing on TIO.
(i=0;While[1>StringCount[IntegerName@i,#],i++];i)&

Try it online!

41 bytes

Excel, 85 bytes
=CHOOSE(CODE(A1)-96,1E3,1E9,1E27,100,,4,8,3,5,,,11,1E6,1,,1E24,1E15,,6,2,4,5,2,6,20,)

2 Golfy bits:

Using exponents (e.g. 1E15) saves 26 bytes.
Default of CHOOSE when nothing is provided is 0, saves 4 bytes

05AB1E, 36 bytes
•—ÃÅ¸usδtθ}™-5„©‘öæH•57в₆-sÇ`èD0‹iÄ°

Port of @recursive's Stax answer.
Input in lowercase.
Try it online or verify all test cases.
Explanation:
•—ÃÅ¸usδtθ}™-5„©‘öæH• # Push compressed integer 3133432551338094772548436198140408157771728287
 57в                  # Converted to base-57 as list: [39,41,43,45,47,30,37,36,12,21,36,42,38,40,41,38,42,56,36,33,27,9,34,36,40,44]
    ₆-                # Subtract 36 from each: [3,5,7,9,11,-6,1,0,-24,-15,0,6,2,4,5,2,6,20,0,-3,-9,-27,-2,0,4,8]
      sÇ`             # Swap to take the input, and convert it to its unicode value
         è            # Index it into the list (with automatic wraparound)
          D0‹i        # Create a copy, and if this is negative:
              Ä       #  Take the absolute value
               °      #  And then take 10 the power this value
                      # (implicitly output the top of the stack as result)

See this 05AB1E tip of mine (section How to compress large integers? and How to compress integer lists?) to understand why •—ÃÅ¸usδtθ}™-5„©‘öæH• is 3133432551338094772548436198140408157771728287 and •—ÃÅ¸usδtθ}™-5„©‘öæH•57в is [39,41,43,45,47,30,37,36,12,21,36,42,38,40,41,38,42,56,36,33,27,9,34,36,40,44].

32. 05AB1E should not lose to Stax!

C# (Visual C# Interactive Compiler), 77 74 68 bytes
x=>((x="1‘Ʊ!  aƁñ"[x-65])&15)*Math.Pow(10,x>>4)

Encodes each letter's output as \$a \times 10^b\$, where \$a\$ is represented by the lowest 4 bits of the character, while \$b\$ is represented by the next five bits after that. Uses capital letters.
Commented
x=>                                                 //Lambda taking in a char
  (x=                                         )     //Re-assign x to
     "1‘Ʊ!   aƁñ"[x-65]      //The character's value at index x-65
 (                                             &15) //Bitwise AND by 15
  * Math.Pow(10,x>>4)                               // Multiplied by 10**(floor(x/16))

Try it online!

Perl 5 -p, 84 bytes
$_=(1e3,1e9,1e27,100,0,4,8,3,5,1,1,11,1e6,1,0,1e24,1e15,0,6,2,4,5,2,6,20,0)[-65+ord]

Try it online!

72 bytes using lookup table from @JoKing's Perl 6 solution

Python 3, 103 bytes
lambda x:(1000,10**9,10**27,100,0,4,8,3,5,0,0,11,10**6,1,0,10**24,10**15,0,6,2,4,5,2,6,20,0)[ord(x)-97]

Try it online!

Perl 6, 67 bytes
{/\-/??10**-$_!!$_}o{'`ZHacgkfhccn]dcKTciegheiwc'.ords[.ord-97]-99}

Try it online!
Uses a lookup table where a negative number means that is the negative of the exponent, otherwise it is the number itself.

05AB1E, 32 bytes
•н“вüQ;æ¡ζæÀÛß%aÜ×₃t•56вsCè2‰`i°

Try it online!
•н“вüQ;æ¡ζæÀÛß%aÜ×₃t•56в  # compressed list:
# [31, 0, 12, 4, 8, 10, 4, 12, 40, 0, 7, 19, 55, 5, 0, 8, 16, 6, 10, 1, 1, 22, 13, 2, 0, 49]

s                         # swap so the input is at the top
 C                        # parse input as "binary" (a -> 36, b -> 37, ...)
  è                       # index (wraps around)
   2‰                     # divmod 2: [n / 2, n % 2]
     `                    # dump both on the stack
      i                   # if the modulo is 1:
       °                  #  10 ** the quotient
                          # implicit output

I still don't get that 'binary' builtin, haha. xD But I guess it can be useful like this sometimes. ;)

@KevinCruijssen It appears to simply convert from "base 255" when it's not valid binary, but still raises digits to powers of 2.

Bash, 129 100 bytes
A=xDVw04835zzbA10SJ0624526k0
c=$[64#${A:$[64#$1-10]:1}]
[ $c -gt 30 ]&&printf 1%0$[c-30].0f||echo $c

Try it online!

Try it online!

How it works:
A=xDVw04835zzbA10SJ0624526k0

$A: Base64 encoded "a"-"z": numbers less than 100 are stored directly. Larger numbers are encoded as the number of zeros +30. (ex: 1,000 = 33, 100 = 32, etc.)
c=$[64#${A:$[64#$1-10]:1}]

Extract one letter from $A at position specified in argument $1 (base64 decoded, -10 to account for offset of 'a'). Base64 decode that character and store in c.
[ $c -gt 30 ]&&printf 1%0$[c-30].0f||echo $c

If $c is greater than 30, print "1" padded with $c-30 zeros. Else, print $c.

Sledgehammer, 17 bytes
Technically, this is 133 bits long, but that doesn't really make this 16.625 bytes, as the compressor claims.
⣜⢍⢞⢹⡱⡋⣽⡱⡆⢺⢦⡽⡐⡌⢗⠈⣵

This probably decodes to
x1 = Input[]; x2 = 0; While[StringFreeQ[IntegerName[x2], x1], x2++]; Print[x2]

(approximately the same as my Mathematica answer), although I barely got it encoded (it appears as though my PC has compatibility issues with everything), so good luck decoding it again to check. I might have made some mistakes while using the encoder, so be careful.

Vyxal, 11 bytes
λ∆ċ‛λ¬-?c;ṅ

Try it Online!
Very literal implementation of the title.
Explained
λ∆ċ‛λ¬-?c;ṅ
λ        ;ṅ  # The first number
 ∆ċ‛λ¬-      #   (converted to words, with any "and"s removed)
       ?c    # to contain the input

Jelly, 36 bytes
Oị“[@ịẆþĊ`o&÷ḲḞṘḂỊP¥t’b48¤_⁹⁵*ɗ¹>?20

Try it online!
A monadic link taking a lower case letter as its argument and returning an integer. Returns 0 for j and k.
Explanation
O                       | Convert to code point
 ị          ¤           | Index into following as a nilad (wraps around):
  “[...t’               | - Integer 5370441668223940717846370165240010583188867 (stored base 250)
         b48            | - Convert to base 48
                 ɗ >?20 | If >20, following as a dyad using 20 as right argument:
             _⁹         | - Subtract right argument (20)
               ⁵*       | - 10 to the power of this
                  ¹     | Else: leave unchanged (identity function)

Retina 0.8.2, 89 bytes
^
$'
T`l`111104835__111011062452620`^.
T`abcm\pq`139285
\d$
$*0$&$*0$&$*0
d
00
T`\lyl`10_

Try it online! Link includes test cases. Explanation:
^
$'

Duplicate the input.
T`l`111104835__111011062452620`^.

Change the first copy to the (first) digit of the relevant result.
T`abcm\pq`139285

If the number has a multiple of 3 trailing zeros, get that multiple now.
\d$
$*0$&$*0$&$*0

And actually convert it into the relevant number of trailing zeros. (Note that this would simplify to *3*0 in Retina 1.)
d
00

Fix up d.
T`\lyl`10_

Fix up l and y and remove any remaining letters.

PHP, 104 bytes
<?=A<($a='^FX]0483500GC10UL0624526P0'[ord($argn)-97])?20==($b=ord($a)%30)||11==$b?$b:str_pad(1,$b,0):$a;

Try it online!
I have a string ^FX]0483500GC10UL0624526P0 which holds a single character for every input letter from "a" to "z". I extract this character based on input and store it in $a. If the character is not a digit, its ASCII code mod 30 will be stored in $b.
If $a is a digit, same digit is printed, this is used for any input that needs an output between 0 and 9 (like "e", "f", etc).
Else if $b is 20 or 11, same number is printed, this is used for "l" and "y".
Else, digit "1" padded to $b with "0"s is printed. For example for input of "a", the character is "^" which has an ASCII code of 94. 94 % 30 = 4 and "1" padded to 4 with "0"s will be "1000".

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


text:
Round away from zero
Round away from zero
Inspired by Round towards zero.
Given a number input via any reasonable method, round the number "away from zero" - positive numbers round up, and negative numbers round down.
If you intend to take the input as a string (via STDIN, for example), you should be able to handle numbers with or without the decimal point. If you take it as a number, it should at least be able to handle floating-point precision (double precision not required) or rational numbers.
You can output a floating-point number with the decimal point (e.g. 42.0) if desired. (Or even have some test cases output floating-point and some output integer, if it makes your answer shorter.)
Standard loopholes are not allowed, etc etc.
Test cases
-99.9 => -100
-33.5 => -34
-7    => -7
-1.1  => -2
0     => 0
2.3   => 3
8     => 8
99.9  => 100
42.0  => 42
-39.0 => -39

Sandbox Link

if we're taking numbers in a string context, such as STDIN, do we need to support the .0 as the test cases seem to suggest?

@JoKing yes-- I will update the question to clarify. This was actually the original case, but then people in the sandbox suggested adding non-decimal test cases so uh, here we are with both, sorry

Feels good to be inspirational :)

It's funny that all the languages that did so well on the previous challenge by taking integer input and integer output won't work so well, since they can't tell the difference between -0.1 and 0.1

Excel, 13 bytes
=ROUNDUP(A1,)

Alternative
=EVEN(A1*2)/2

EVEN, what a strange function..

@tsh I think you mean "odd function".

@negativeseven Username checks out. :-P

R, 32 bytes
x=scan()
sign(x)*ceiling(abs(x))

31 bytes -- very nice answer!

25 bytes

Jelly, 4 bytes
ĊṠ¡Ḟ

A monadic Link accepting a number which yields an integer.
Try it online! Or see a test-suite.
How?
ĊṠ¡Ḟ - Link: number, N
  ¡  - repeat...
 Ṡ   - ...number of times: sign of N (repeating -1 is the same as 0 times)
Ċ    - ...action: ceiling
   Ḟ - floor (that)

So how exactly does ¡ work for negative numbers? I don't think it's documented

It's not documented on Jelly's wiki, but ¡s repetitive nature is implemented with a for index in range(repetitions) loop in the code. range([stop=]-1) is empty since start defaults to 0 and step defaults to 1 and "For a positive step, the contents of a range r are determined by the formula r[i] = start + step*i where i >= 0 and r[i] < stop." docs

¡'s behavior relies on that of Python's range, and range(-1).__iter__().__next__() immediately throws StopIteration.

Vim, 36 bytes/keystrokes
:s/-/-<Space>
:g/\..*[1-9]/norm <C-v><C-a>lD
:s/<Space><cr>

Try it online! or Verify all Test Cases!
Explanation:
:s/             " Replace...
   -            "   A dash
    /-<Space>   "   With a dash and a space

:g/                             " On Every line matching this regex...
   \.                           "   A dot
     .*                         "   Followed By anything
       [1-9]                    "   Followed by a digit other than 0
            /norm               " Run the following keystrokes...
                  <C-v><C-a>    "   Increment the number by 1
                                "   This also conveniently places our cursor just before the dot
                            l   "   Move one character right
                             D  "   Delete everything after the cursor

:s/             " Replace...
   <Space>      "   A space
                "   (With nothing)

Using $F-a <esc> instead of the first line and a macro with / as a conditional in place of :g and :norm gives 29 bytes https://tio.run/##HczBCoJAFEZhWva/QpuLCNbizoxalBXRInqJMpjGCYVwmkx7/Ilcn49z110drKkdJSE@s6ZZ7L28istNlThNfN8f/baThJAcDL5187T0trqiZkeVw1S610cOciBD/KD9fFxFcRMtiFtUrrWBU5WBi0IU4DwXK/AanIoUCpnIscEyEwpj/8sf

Java (JDK), 18 bytes
d->d.setScale(0,0)

Try it online!
Explanations
Uses a BigDecimal as input and output. BigDecimal has a method setScale that sets the scale of the number. The first parameter is the number of digits after the dot separator, the second is the rounding mode. ROUND_UP is the "away-from-zero" rounding and has a value of 0 so I hardcode that value.

Jelly, 5 4 bytes
AĊ×Ṡ

Try it online!
This ports recursive's Stax answer into Jelly, so check that answer out for an explanation.
-1 byte thanks to Nick Kennedy
Jelly, 6 5 bytes
ĊḞ>?0

Try it online!
-1 byte thanks to Jonathan Allan
How this one works
ĊḞ>?0 - Monadic link. Takes a float, x, as argument

   ?  - If:
  > 0 -   x > 0
      - Then:
Ċ     -   ceil(x)
      - Else:
 Ḟ    -   floor(x)

ĊḞ>?0 would work as your 6 does.

AĊ×Ṡ is 4 and functionally identical to your first answer.

@NickKennedy and Jonathan, thanks for the suggestions, they've been edited in

Python 3, 23 bytes
lambda i:i-i%(1|-(i>0))

Try it online!
-1 byte thanks to xnor

You can do (1|-(i>0)) to save a byte off (1,-1)[i>0].

@xnor Nice find, thanks!

Well done. I had it at 62 bytes ಥ_ಥ: g=lambda r:0if r==0 else(int(r)+r/abs(r)if r/int(r)!=1 else r)

What is the '|' before the '-'?

@William bitwise or.

Yeah, really nice solution. I got stuck at lambda i:i//1+(i>0<i-i//1) with 26 bytes

lambda i:i//1+(i%-1<0<i) 24.. wow, I guess it is unbeatable

@jaaq I really like that solution too! My initial approach was also 24 bytes.

JavaScript (ES6), 20 bytes
n=>n%1?n<0?~-n:-~n:n

Try it online!
Commented
n =>        // n = input
  n % 1 ?   // if n is not an integer:
    n < 0 ? //   if n is negative:
      ~-n   //     return -(floor(-n) + 1) = -floor(-n) - 1
    :       //   else:
      -~n   //     return -(-(floor(n) + 1)) = floor(n) + 1
  :         // else:
    n       //   return n unchanged

I was writing an answer for my 16-byte answer (n=>(~~n-n%1)%1+n) until I found out that my code didn't work for numbers between -1 and 1. You might be able to figure out how to make this work with the last 3 bytes there's left!

Runic Enchantments, 18 16 bytes
1µ-i:'-A{*+'.A@

Try it online!
"Adds" (away from zero) 0.999999 and floors the result. µ is the closest thing to an infinitesimal in language's operators. With a properly functioning Trunc(x) command, answer now supports 0 as input.

@JoKing Oof. Good catch. It's doing a divide by input to get the "sign" of the input value, which of course, divides by 0 when the input is 0. There's no (good) way around that right now. Will need this commit first. I'll poke Dennis (side benefit, the answer will get shorter).

@JoKing Answer now handles 0 correctly.

Stax, 6 bytes
å├╪∙Bß

Run and debug it
Procedure:

Absolute value
Ceiling
Multiply by original sign

The tool I'm using says this is 14 bytes

Your tool is probably not aware of the stax character encoding.  If you're still not convinced, in the "Tools" section, there's a download link, where you can actually download the source file and inspect its size for yourself.

J, 6 bytes
**>.@|

Try it online!
Just a 1 character change from my answer on the cousin question.

C# (Visual C# Compiler), 41 bytes27 bytes24 bytes
s=>(int)s+Math.Sign(s%1)

Try it online!
First post here, had fun with it, hope u like it.
Kinda felt C# place is empty here
-14 tnx to @expired data
-3 tnx to @night2

Welcome to the site, and nice first answer! Hope you enjoy Code Golf!

27 bytes... Probably still a few to save

@Expired, yea nice, this kind of coding was so weird at first glance that looks like I forgot about whole library thing, mind to post it as an answer

Nah just update your answer and use  for strikethrough to reduce the bytes :)

@expired data, tnx, now c# can be in competition too :)

I don't think that you needed the += assignment and parentheses, this seems to work too: 24 bytes

You also need to update your "Try it online!" link in your answer. Instead of typing the whole answer, you can use TIO's export options. In "tio.run", after you are finished with your code, just click on the link icon on top (), then copy the "Code Golf submission (Stack Exchange)" section here.

@Night2, tnx for the comment, I didnt type the whole answer, I used the Code golf submission functionality, Just added a bit of my own words to the end, but for edit I just changed that code line, and u r right there, i forgot to update the link, which brings us back to the first step, to only modify once, kinda SOLID here, anyway, tnx for the hint too

You've edited your TIO link to the 24 byte version, but the code line itself is still the 27 byte version.

C, 94 43 39 bytes
thanks to ceilingcat for 39 bytes
#define f(n)(int)(n>0?ceil(n):floor(n))

TIO

48

Husk, 5 bytes
*±¹⌈a

Try it online! Just takes the sign of the input times the ceiling of its absolute value.

Alternative 5-byter: ?⌊⌈<0

Retina 0.8.2, 38 bytes
\.0+
.
\b9+\..
0$&
T`9d`d`.9*\..
\..*

Try it online! Link includes test cases. Explanation:
\.0+
.

Delete zeroes after the decimal point, to ensure that the number is not an integer; the next two matches fail if there are no digits after the decimal point.
\b9+\..
0$&

If the integer part is all 9s, prefix a 0 to allow the increment to overflow.
T`9d`d`.9*\..

Increment the integer part of the number.
\..*

Delete the fractional part of the number.

Perl 6, 18 bytes
{$_-.abs%-1*.sign}

Try it online!
Explanation
{                }  # Anonymous block
    .abs  # Absolute value
        %-1  # Modulo -1
           *.sign  # Multiply by sign
 $_-  # Subtract from original

05AB1E, 6 bytes
ÄîI.±*

A 5-byter should definitely be possible..
Try it online or verify all test cases.
Explanation:
Ä       # The absolute value of the (implicit) input,
 î      # ceiled
     *  # And then multiplied by
   .±   # the signum
  I     # of the input
        # (after which the result is output implicitly)

Wolfram Language (Mathematica), 18 bytes
Sign@#⌈Abs@#⌉&

Try it online!

PHP, 30 bytes
<?=0^$argn-=0<=>fmod($argn,1);

Try it online!
If number is not integer, based on the sign -1 (for negative decimals) or 1 (for positive decimals) is added to it and then integer part of the new number is printed.

PHP, 32 bytes
<?=[ceil,floor][$argn<0]($argn);

Try it online!
Basically outputs floor of input if it is less than 0, else ceil of it.

PHP, 34 bytes
<?=($argn>0?:-1)*ceil(abs($argn));

Try it online!

MathGolf, 5 bytes
‼σ±ü*

Try it online!
Explanation
It's nice to find usage for the ‼ operator.
‼       apply next two operators to (implicit) input
 σ      sign (-1, 0, or 1)
  ±     absolute value
   ü    ceiling of that absolute value
    *   multiply the rounded absolute value with the sign

Brachylog, 7 bytes
⌋₁ℤ₁|⌉₁

Try it online!
or ⌉₁ℕ₁|⌋₁.
⌋₁         The input rounded down
  ℤ₁       is an integer less than -1
    |      and the output, or, the input
     ⌉₁    rounded up is the output.

Perl 5 -pF/\./, 35 bytes
$_&&=$F[0]+($_!=int&&$_*(@F-1)/abs)

Try it online!

fails 3.0.  For switches, -pF\. is sufficient: the // are optional.

also 0.0 is true

Fixed both of those.

Factor, 57 bytes
: f ( x -- x ) [ signum ] [ abs ceiling ] bi * >integer ;

Try it online!

APL (Dyalog Unicode), 15 bytes
{⍎'⌈⌊'[0>⍵],⍕⍵}

Try it online!
Simple Dfn. Uses ⎕IO←0.
How:
{⍎'⌈⌊'[0>⍵],⍕⍵} ⍝ Main function, argument ⍵.
            ⍕⍵  ⍝ Stringified argument
           ,    ⍝ Appended to
      [0>⍵]     ⍝ This item... (0 if ⍵ is positive or 0, else 1)
  '⌈⌊'          ⍝ of this string (which are the functions Ceiling and Floor, respectively)
 ⍎              ⍝ Executed as APL code.

sed, 131 bytes + 2 bytes for -r flag
/^-?[^.]*(\.0*)?$/bQ
s/^(-?)9/\109/
s/([0-8]9*)\..*$/_\1/
h
s/.*_//
y/0123456789/1234567890/
G
s/(.*)\n(.*)_(.*)/\2\1/
:Q
s/\..*$//

Ungolfed
#!/bin/sed -rf

# identify integers
/^-?[^.]*(\.0*)?$/ b isInt

# add a leading 0 if we'll need it later
s/^(-?)9/\109/

# convert to format: -?[0-9]_[0-8]9*
s/([0-8]9*)\..*$/_\1/

# move the part that will remain constant into the hold buffer
h
s/.*_//

# [0-8]9* can be incremented via character substitution
y/0123456789/1234567890/

# reassemble parts
G
s/(.*)\n(.*)_(.*)/\2\1/

:isInt
# Get rid of anything after the decimal point
s/\..*$//

JavaScript (node.js), 30 23 21 bytes
s=>~~s+Math.sign(s%1)

Inspired by the C# answer.
Thanks to @Value Ink and @Gust van de Wal for -7 bytes!
Thanks again, @Gust van de Wal for another -2 bytes!

Why use += when + will do the trick in this case? -1 byte

Instead of parseInt(), I'd just use ~~ at the start or another bitwise operator like |0 or ^0 at the end to save another chunk of bytes

@ValueInk wow, I have no idea why I wrote +=, thx for pointing it out

You can still drop the the outer parentheses

@GustvandeWal oh, I didn't know that! thanks

Math.sign(s%1) => s%1?s>0||-1:0?

Julia 1.0, 17 bytes
Save 6 bytes thanks to the awesome comments of MarcMush!
x->x+sign(x%=1)-x

Try it online!
An alternative with 22 bytes
x->sign(x)ceil(abs(x))

Try it online!

Thanks! I didn't know the %= that can be very useful in codegolf

Vyxal r, 5 4 bytes
Built-ins I previously didn't know existed FTW!
ȧ⌈∆±

Try it Online!
Explanation:
      # Implicit input
ȧ     # Absolute value
 ⌈    # Ceiling
  ∆±  # Change to the sign of input
      # Implicit output

PowerShell Core, 54 48 bytes
$a,$u=$args-split'\.'
(1,-1)[2*!+$u+($a-lt0)]+$a

Try it online!
Thanks @mazzy for the improved golfing !
Original implementation
$a,$u="$args"|% s*t '.'
(((1,-1)[$a-lt0]+$a),$a)[!+$u]

Try it online!
Explanations
$a,$u="$args"|% s*t '.'        # splits the input as a string using '.'
                        [!+$u] # if there are no decimals
(                   ,$a)       # return the int part as is
 ((1,-1)[$a-lt0]+$a)           # return the int part + or - one depending of the sign of the input

Try it online! ?

PowerShell Core, 45 38 37 bytes
[int]("$args"-replace'\.0*[^0]','.9')

Try it online!

Risky, 20 bytes
_?{0-1?{0/_?{1+_0+0+1?{0+_0+0+_0+0+_0+0

Try it online!
Takes a pair representing a rational number.

Java (OpenJDK 8), 43 bytes
a->{return(int)((int)a/a<1?a>0?a+1:a-1:a);}

Try it online!

The lambda function can be written without using an explicit return statement.

@Joel is indeed right. And you can save 4 additional bytes changing the (int)a/a<1 to a%1!=0: 30 bytes

There's also the BigDecimal.setScale method that gives excellent results, like my answer demonstrates

33 bytes

Perl 6, 19 bytes
{$_+|0+.sign*?/\./}

Try it online!
Not the shortest solution, but I'm working on it. Basically this truncates the number, then adds one away from zero if the number was not whole to begin with

Japt, 6 bytes
Î*Ua c

Try it here

Red, 46 bytes
func[n][(pick[0 1]n = t: to 0 n)*(sign? n)+ t]

Try it online!
The slightly more readable version is 2 byte longer (those long function names!):
func[n][to 1(sign? n)* round/ceiling absolute n]

Scala, 16 bytes
_.setScale(0,UP)

Try it online!
Scala, 22 bytes
x=>x.signum*x.abs.ceil

Try it online!

Zsh, 43 36 35 bytes
Try it online! Try it online! Try it online!
Using nested ternaries, for extra confusion. XOR logic from the round to 0 solution.
x=$1
<<<$[(x^0-x?x+(x<0?-1:1):x)^0]

Explanation:
x=$1                                    #set x
         x^0-x?                         #if x has decimals (shorter than x^0!=x)
                                        #(0 is falsy in this context)
                    x+(x<0?-1:1)        #  if x<0 subtract 1 else add 1
                                :x      #otherwise the result is just x
<<<$[(                            )^0]  #truncate to int & output

APL(Dyalog Unicode), 5 bytes SBCS
××⌈∘|

Try it on APLgolf!
A train submission which takes a number on the right. Uses recursive's idea.

MMIX, 16 bytes (4 instrs)
40000002 17000200 17000300 F8010000

Disassembly / Explanation
rfz BN   $0,0F              // if negative, skip next instruction
    FINT $0,ROUND_UP,$0     // round to integer towards +inf
0H  FINT $0,ROUND_DOWN,$0   // round to -inf, no effect if already rounded
    POP  1,0                // return


text:
ASCII Maze Rendering 3000
I don't like typing, so I draw my mazes in a very simple format:
# #####
#     #
# ### #
# # # #
#   # #
##### #

Isn't it a-maze-ing? Of course, I think all mazes should look 3d, similar but not he same as this challenge, for maximum a-maze-ingness, so I (grudgingly) manually updated the maze to look like this:
+-----+     +-----------------------------+
|\     \    |\                             \
+ \     \   + \                             \
 \ \     \   \ +-----------------------+     \
  \ \     \   \|                       |\     \
   \ \     \   +-----------------------+ \     \
    \ \     \     +-----------------+   \ \     \
     \ \     \    |\                 \   \ \     \
      \ \     \   + \                 \   \ \     \
       \ \     \   \ \     +-----+     \   \ \     \
        \ \     \   \ \     \    |\     \   \ \     \
         \ \     \   \ \     \---+ \     \   \ \     \
          \ \     \   \ +-----+   \ \     \   \ \     \
           \ \     \   \|     |    \ \     \   \ \     \
            \ \     \   +-----+     \ \     \   \ \     \
             \ \     +-----------------+     \   \ \     \
              \ \                             \   \ \     \
               \ \                             \   \ \     \
                \ +-----------------------------+   \ +-----+
                 \|                             |    \|     |
                  +-----------------------------+     +-----+

Unfortunately, it's difficult to work with mazes in that format, and after all that manual typing, I don't want to just retype the original, so I need you to write a program to do the reversal for me.
Rules

Input will be a multiline string or character matrix consisting only of " ", "|", "\", "+", "-", and newlines.
Output consists of " " and "#", in the pattern described by the maze.
Due to my amazing maze designing skills, you can assume nothing about the structure of the maze, other than that is has a valid deconstruction.
In the 3d-ification, (the process you must now undo,) each # was converted to this 3x4x7 character block:

+-----+
|\     \
+ \     \
 \ +-----+
  \|     |
   +-----+

Adjacent blocks were joined together, like this:

+-----+-----+
|\     \     \
+ \     \     \
 \ +-----+-----+
  \|\     \     \
   + \     \     \
    \ +-----+-----+
     \|     |     |
      +-----+-----+

but without joining lines, so it actually looks like this:

+-----------+
|\           \
+ \           \
 \ \           \
  \ \           \
   \ \           \
    \ +-----------+
     \|           |
      +-----------+

Concave spaces sometimes block parts of other walls.

+-----------+
|\           \
+ \           \
 \ \     +-----+
  \ \     \    |
   \ \     \---+
    \ +-----+
     \|     |
      +-----+

Trailing whitespace in the input or output is acceptable. (You must specify if your answer requires trailing whitespace in the input.)
Leading whitespace must correspond to empty spaces in the input.
I still don't like typing, so shortest code wins

Test cases:
Input:
+-----+     +-----------------------------+
|\     \    |\                             \
+ \     \   + \                             \
 \ \     \   \ +-----------------------+     \
  \ \     \   \|                       |\     \
   \ \     \   +-----------------------+ \     \
    \ \     \     +-----------------+   \ \     \
     \ \     \    |\                 \   \ \     \
      \ \     \   + \                 \   \ \     \
       \ \     \   \ \     +-----+     \   \ \     \
        \ \     \   \ \     \    |\     \   \ \     \
         \ \     \   \ \     \---+ \     \   \ \     \
          \ \     \   \ +-----+   \ \     \   \ \     \
           \ \     \   \|     |    \ \     \   \ \     \
            \ \     \   +-----+     \ \     \   \ \     \
             \ \     +-----------------+     \   \ \     \
              \ \                             \   \ \     \
               \ \                             \   \ \     \
                \ +-----------------------------+   \ +-----+
                 \|                             |    \|     |
                  +-----------------------------+     +-----+

Output:
# #####
#     #
# ### #
# # # #
#   # #
##### #

Input:
+-----+
|\     \
+ \     \
 \ +-----+
  \|     |
   +-----+

Output:
#

Input:
      +-----------------+
      |\                 \
      + \                 \
   +-----+     +-----+     +-----+
   |\           \    |\           \
   + \           \---+ \           \
    \ \     +-----+   \ +-----+     \
     \ \     \    |    \|     |\     \
      \ \     \---+     +-----+ \     \
       \ \     +-----+     +-----+     \
        \ \           \    |\           \
         \ \           \   + \           \
          \ +-----+     +-----+     +-----+
           \|     |\                 \    |
            +-----+ \                 \---+
                   \ +-----------------+
                    \|                 |
                     +-----------------+

Output:
 ###
## ##
#   #
## ##
 ###

Input:
+-----------------------------------------------------------------------------------------------------+
|\                                                                                \
+ \                                                                                \
 \ +-----------------------------------------------+     +-----------------------------------------+     \
  \|                                               |\     \                                        |\     \
   +-----------------------------------------------+ \     \---------------------------------------+ \     \
      +-----+     +-----------------------------+   \ \     \     +-----------------------------+   \ \     \
      |\     \    |\                             \   \ \     \    |\                             \   \ \     \
      + \     \   + \                             \   \ \     \   + \                             \   \ \     \
       \ \     \   \ +-----------+     +-----+     \   \ \     \   \ +-----------------------+     \   \ \     \
        \ \     \   \|           |\     \    |\     \   \ \     \   \|                       |\     \   \ \     \
         \ \     \   +-----------+ \     \---+ \     \   \ \     \   +-----------------------+ \     \   \ \     \
          \ \     \     +-----+   \ \     \   \ \     \   \ \     +-----------------------+   \ \     \   \ \     \
           \ \     \    |\     \   \ \     \   \ \     \   \ \                             \   \ \     \   \ \     \
            \ \     \   + \     \   \ \     \   \ \     \   \ \                             \   \ \     \   \ \     \
             \ \     \   \ +-----+   \ \     \   \ \     \   \ +-----------------------------+   \ \     \   \ \     \
              \ \     \   \|     |    \ \     \   \ \     \   \|                             |    \ \     \   \ \     \
               \ \     \   +-----+     \ \     \   \ \     \   +-----------------------------+     \ \     \   \ \     \
                \ \     +-----------+   \ \     \   \ \     +-----------------------------------+   \ \     \   \ \     \
                 \ \                 \   \ \     \   \ \                                         \   \ \     \   \ \     \
                  \ \                 \   \ \     \   \ \                                         \   \ \     \   \ \     \
                   \ \     +-----------+   \ \     \   \ \     +-----------------------+     +-----+   \ \     \   \ \     \
                    \ \     \          |    \ \     \   \ \     \                      |\     \    |    \ \     \   \ \     \
                     \ \     \---------+     \ \     \   \ \     \---------------------+ \     \---+     \ \     \   \ \     \
                      \ \     \     +-----------+     \   \ \     \     +-----------+   \ \     \     +-----+     \   \ +-----+
                       \ \     \    |\                 \   \ \     \    |\           \   \ \     \    |\           \   \|     |
                        \ \     \   + \                 \   \ \     \   + \           \   \ \     \   + \           \   +-----+
                         \ \     \   \ +-----------------+   \ \     \   \ \           \   \ +-----+   \ +-----+     \
                          \ \     \   \|                 |    \ \     \   \ \           \   \|     |    \|     |\     \
                           \ \     \   +-----------------+     \ \     \   \ \           \   +-----+     +-----+ \     \
                            \ \     +-----------------------------+     +-----+           +-----------------------+     +-----------+
                             \ \                                                                                \
                              \ \                                                                                \
                               \ +-----------------------------------------------------------------------------------------------------+
                                \|                                                                                |
                                 +-----------------------------------------------------------------------------------------------------+

Output:
#################
        #       #
# ##### # ##### #
#   # # #     # #
# # # # ##### # #
#   # #       # #
### # ####### # #
#   # #    #  # #
# ### # ## # ##
#     # ##    #
#################

Input:
+-----------------+
|\                 \
+ \                 \
 \ \                 \
  \ \                 \
   \ \                 \
    \ \                 \
     \ \                 \
      \ \                 \
       \ +-----------------+
        \|                 |
         +-----------------+

Output:
###
###
###

Input: (Note leading whitespace)
      +-----+     +-----+
      |\     \    |\     \
      + \     \   + \     \
   +-----+-----+-----+-----+
   |\     \    |\     \    |
   + \     \---+ \     \---+
    \ +-----+-----+-----+-----+
     \|     |\     \    |\     \
      +-----+ \     \---+ \     \
         +-----+-----+-----+-----+
         |\     \    |\     \    |
         + \     \---+ \     \---+
          \ +-----+   \ +-----+
           \|     |    \|     |
            +-----+     +-----+

Output:
 # #
# #
 # #
# #

Can input/output be a list of strings?

@Nick yes. That is what I meant by character matrix.

great just wanted to clarify!

I really like this challenge! Just curious, why this way round and not producing the 3d maze?

@AJFaraday Producing the maze (and more) has already been done in the challenge I linked.

@Hiatsu Good point, well made.

Python 2, 81 bytes
def f(M,k=1,r='',b=0):
 for c in M[k][k::6]:b^=c>' ';r+=' #'[b]
 print r;f(M,k+3)

Try it online!
Takes input as a list of strings (or a list of lists of characters). Prints the output, terminating with error.
The idea is similar to tsh's. We look at the characters marked as ? below to see which are spaces and which are \:
+-----------+
|?     ?     ?
+ \           \
 \ \     +-----+
  \ ?     ?    |?
   \ \     \---+
    \ +-----+
     \|?    |?
      +-----+

Within each row with ?'s, a \ marks a vertical ridge between a filled cell and an empty cell of the maze. Because these ridges are in top layer of the maze, their \ characters are never obscured by another maze element.
To look at the ? positions, the code iterates through rows k=1,4,7,... (zero-indexed), and in each row looks at every 6th position starting with position k. It tracks whether we're in an empty or full cell in the bit b, and flips that bit whenever a \ is encountered. After each character read, it appends the character for empty () or full (#) according to b, and prints the resulting string after the row is complete.

That. Is. IMPRESSIVE.

JavaScript (Node.js), 85 bytes
a=>a.flatMap(u=(l,y)=>y%3?[]:[l.flatMap((c,x)=>x<y|(x-=y+3)%6?[]:' #'[u[x]^=c+1<0])])

Try it online!
Basic idea is: we only care about the characters on \$ (6x+3y+3,3y) \$. If it is a dash (-), current cell has the different value with the one on its top, and if it is a space (), current cell has the same value.
Thanks @Arnauld, saved 7 bytes

very nice insight

Jelly, 22 20 bytes
ṫ"J‘$m3n⁶m€6Ż^\ị⁾# Ḋ

Try it online!
A monadic link taking a Jelly string as input and returning the processed maze as a Jelly string including one row of trailing whitespace.
1 byte Ḋ could be saved if a single line of leading whitespace were acceptable.
Took some inspiration from @tsh’s formula, so be sure to upvote that one too!
Explanation
ṫ"  $                | Tail each string using a paired member of the following:
  J                  | - Sequence along the list of strings
   ‘                 | - Incremented by 1
     m3              | Take every 3rd string (1st, 4th, 7th, ...)
       n⁶            | Not equal to space character
         m€6         | Within each list take every 6th item (1st, 7th, ...)
            Ż        | Prepend a zero to the list
             ^\      | Reduce using xor, collecting up results; vectorised across lists (so starts with 0 xor first list, then output of that xor second list, and so on)
               ị⁾#   | Index into "#", " "
                   Ḋ | Remove first list

05AB1E, 25 22 bytes
-1 byte thanks to Kevin Cruijssen
εN3%iN.$6ιнηðÊO„ #sèJ,

Try it online!
Port of xnor's Python answer. Takes input as a character matrix. The TIO link shows input as a multiline string for readability, with the |€S header converting that to the character matrix format.

24 bytes: ε'\¢„ #sè} to ðм€g„ #sè

Wow, nice find! See the answer for further improvements. PS: I am confused about the difference between м and K.

Retina 0.8.2, 72 bytes
¶(?<=(.|(¶))+)(?<-2>.)+
¶
-4G`
.+¶(.+)¶.+
$1
T` `#`\\  +\\
.(.)....|.
$1

Try it online! Explanation:
¶(?<=(.|(¶))+)(?<-2>.)+
¶

De-skew all of the lines.
-4G`

Delete the last three lines as I don't need them.
.+¶(.+)¶.+
$1

Keep only the middle of each group of three lines. (In Retina 1, I believe the above two stages can be done in a single stage: ,G1,3,-5`.)
T` `#`\\  +\\

Fill in the faces of the blocks.
.(.)....|.
$1

Keep only the second character of each block.

C (clang), 120  117 bytes
o,c,t,s,r;f(char*m){for(s=o=0;*m;!r?t^=*m!=32,s=t?35:46:0)*++m==10?m-=~++o,c=t=0,s=10:0,r||printf(&s),r=c++%6|o%3-1;}

Try it online!
Inspired by the others answers.
'\'=92   ' '=32=>46='.'  '#'=35   '\n'=10
// o offset == // l line
// c line counter
// t toggle
// r => ? test, point to inspect
for(o=s=0;*m;
!r?t=*m-32?!t:t,s=t?35:46:0) // t^=*m!=32 @ceilingcat
// if test(r) is enabled: toggle(t) and sets (s)

*++m==10?m-=~++o,c=t=0,s=10:0,
// next char => if it's \n overwrites (s)
// and increments offset(o) and move pointer(m)

r || printf (&s)
// r or print! Thanks to @ceilingcat
// instead of
    *++m-10?0:(m-=~++o,c=t=0,s=10),
    !r*s?putchar(s):0,
 Saved 5 !

r=c++%6|o%3-1;// enable test every 6 x 3+1 positions