[Question]
  [
# Introduction
The game [Minecraft](https://minecraft.net) has a 1 in 10000 chance of showing "Minceraft" instead of "Minecraft" on the title screen.
# Your challenge
Your challenge is to code a function or program that takes no input, and on average 1 of 10000 times, returns "Minceraft" and the rest of the time returns "Minecraft".
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest wins!
  
[Answer]
# Minecraft, ~~358~~ ~~293~~ ~~277~~ 276 bytes
*Implementing Minceraft in Minecraft*
Should be run as a set of commands in game. Should be run on a fresh superflat (redstone ready) world.
Byte count is the amount of characters you need to type, including newlines.
```
/scoreboard objectives add s dummy
/summon bat
/execute as @e[type=bat] store result score o s run data get entity @s UUID[1]
/scoreboard players set c s 2147054151
/execute if score o s < c s run tellraw @s "Minecraft"
/execute if score o s >= c s run tellraw @s "Minceraft"
```
The UUID of an entity is (mostly) randomly generated and stored as four signed 32 bit integers. One of the integers is compared with `2147054151` which is one ten thousandth of the way between `2^31` and `-2^31`.
Previous solution because it was so high effort and I'm not deleting it:
## Minecraft, 293 bytes
```
/scoreboard objectives add s dummy
/summon horse
/execute as @e[type=horse] store result score o s run data get entity @s Attributes[1].Base 100000
/scoreboard players set c s 11883
/execute if score o s >= c s run tellraw @s "Minecraft"
/execute if score o s < c s run tellraw @s "Minceraft"
```
### How does it work?
In Minecraft, there are only a limited amount of sources of reliable randomness usable in commands. In Minecraft Functions you can use predicates with specific random chances, but that requires multiple files and submitting that as a zipped data pack would be at least 1 KB.
To avoid this and have it run solely from commands a player can type in, this uses horses as a random source. When a horse is spawned, it is assigned a random speed between 0.1125 and 0.3375 (the units are arbitrary). The random speed calculation is as follows:
$$0.25(0.45 + 0.3x + 0.3y + 0.3z)$$
Where *x*, *y*, and *z* are uniform independent random variables **[0, 1)**. If you find the cumulative density function by convolving the distribution functions (to get the PDF) and then integrating, you will end up with the following piecewise function:
$$
f(x)=\begin{cases}-\frac{9}{16}+15x-\frac{400x^{2}}{3}+\frac{32000x^{3}}{81}&\frac{9}{80}\le x<\frac{3}{16}\\
\frac{29}{4}-110x+\frac{1600x^{2}}{3}-\frac{64000x^{3}}{81}&\frac{3}{16}\le x<\frac{21}{80}\\
-\frac{227}{16}+135x-400x^{2}+\frac{32000x^{3}}{81}&\frac{21}{80}\le x<\frac{27}{80}
\end{cases}
$$
We need to find the horse speed where the probability of a horse with that speed or lower spawning is one in ten thousand or 0.0001. This can be done by solving the first equation:
$$-\frac{9}{16}+15x-\frac{400x^{2}}{3}+\frac{32000x^{3}}{81} = 0.0001\\
f^{-1}(0.0001)\simeq0.11882574$$
This results in the horse speed being multiplied by 100,000 (because scoreboard values must be integers) and compared with 11883 in the code.
The precision is currently 1.00202 in 10,000. Two bytes can be added or removed for approximately each order of magnitude required. Two additional bytes will make it 1.00012 in 10,000.
[Answer]
# Python 3, ~~63~~ 59 bytes
My idea was to use the `time` module as a PRNG since the challenge stated
> 
> on average 1 of 10000 times, returns "Minceraft" and the rest of the time returns "Minecraft"
> 
> 
> 
and taking the time mod 10000 does exactly that.
Thanks [@movatica](https://codegolf.stackexchange.com/users/86751/movatica) for -4
```
import time
print(f"Min{'ceec'[time.time()%1e4>1::2]}raft")
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PzO3IL@oRKEkMzeVq6AoM69EI03JNzOvWj05NTVZPRokrgciNDRVDVNN7AytrIxia4sS00qUNP//BwA)
Alternative, also 59 bytes:
```
import time
print("Min%sraft"%"ceec"[time.time()%1e4>1::2])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PzO3IL@oRKEkMzeVq6AoM69EQ8k3M0@1uCgxrURJVSk5NTVZKRokqwciNDRVDVNN7AytrIxiNf//BwA)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~78~~ ~~71~~ ~~69~~ 68 bytes
```
from random import*
f=lambda:f'Min{randint(0,1e4)and"ec"or"ce"}raft'
```
[Try it online!](https://tio.run/##FYyxCoAwEEN3v6J00YqDopPgJ/gRVXt6YO/K0UXEb69tlhBekvDEi2lMCYS9EktHNvSBJbYVLLf122FnqFekt1Ck2PTd4CaTg3a7ZtG7059YiHUCFoUKqRydrhT7LDMHKTtojEk "Python 3 – Try It Online")
-7 bytes thanks to [@Alex bries](https://codegolf.stackexchange.com/users/99744/alex-bries)
-2 bytes thanks to [@Alex bries](https://codegolf.stackexchange.com/users/99744/alex-bries)
[Answer]
## Python 3 - ~~45~~ ~~42~~ 41 Bytes
41 bytes with the constraint of running from a different process every run.
```
print(f"Min{'ceec'[id(0)%4e4>1::2]}raft")
```
42 bytes with limited randomness unless running a different process each time [\*].
```
print(f"Min{'ceec'[id({})%4e4>1::2]}raft")
```
The idea was to use the same wrapper as in [here](https://codegolf.stackexchange.com/a/224450/103702), but a different RNG:  
Create a new object (a ~~set~~ dict in this case, because it takes ~~5~~ 2 characters ~~`set()`~~ `{}`), and take the `id()` of that, which is its memory address.
The memory address acts like a uniform hash[\*], which has ~~`1/10000`~~ `1/40000` (thanks @ovs) chance to end with zeros.
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EI03JNzOvWj05NTVZPTozRaM4tURDU1PVMNXEztDKyii2tigxrURJ8/9/AA "Python 3 – Try It Online")
**Update to 42 bytes:**  
Instead of `set()`, use `{}` which is the `dict` constructor. Can't go shorter for dynamic object creation.
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EI03JNzOvWj05NTVZPTozRaO6VlPVMNXEztDKyii2tigxrURJ8/9/AA "Python 3 – Try It Online")
**Update to 41 bytes:** - use static object creation!  
Thanks to @dingledooper  
**Works only if the program is run in a different process every run!**  
Instead of `{}`, use `0`.  
`0` is an object in Python, so it has an address in virtual memory, and that address is constant for that object during the lifetime of the program. If we were to run that in a for loop, it would not be random.  
However, if we run it in a new process every run, we get the desired randomness. This is the case in a [stateless server](https://tio.run/##K6gsycjPM/7/v6AoM69EI03JNzOvWj05NTVZPTozRaO6VlPVJNXEztDKyii2tigxrURJ8/9/AA "Python 3 – Try It Online").
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EI03JNzOvWj05NTVZPTozRaO6VlPVJNXEztDKyii2tigxrURJ8/9/AA "Python 3 – Try It Online")
[\*] - Objects in Python are freed immediately when they are no longer referenced (reference counting). Thus, running the solution in a loop might always output the same id, as the memory is freed and allocated at the same address. This is OS dependent, and environment dependent, thus may not work as expected, or in a reproducible way.  
Running a new process each time solves this issue.
[Answer]
# JavaScript, 37 bytes
```
_=>`Min${new Date%1e4?'ec':'ce'}raft`
```
[Try It Online](https://tio.run/##y0osSyxOLsosKNEts/ifZvs/3tYuwTczT6U6L7VcwSWxJFXVMNXEXj01Wd1KPTlVvbYoMa0k4X9afpFGpq2BtbZ2po1hqpG1ZnJ@XnF@TqpeTn66RpqGpuZ/AA)
First of all, write `Min`.
Then get the current time with `new Date`. Normally it returns something similar to "2021-10-05T10:29:58.432Z". But if you do a mathematical operation on it, this output becomes the epoch time similar to "1633429932422" (a number, basically).
Now divide the number by 10000 (1e4). If the remainder (%) is `0` i.e. `false`, add `ce` to `Min` otherwise add `ec`.
At last, add `raft` at the end.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 48 bytes
```
f(){printf("Min%sraft",rand()%10000?"ec":"ce");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NQ7O6oCgzryRNQ8k3M0@1uCgxrURJpygxL0VDU9XQAAjslVKTlayUklOVNK1r/wOVKuQmZuZpaHJVcykAQVp@kYIGSDRPwVbBwBpI2SgYA2lt7TxNBYgSsDINTWs4B2ZjTJ4SVLSWq/b/v@S0nMT04v@65QA "C (gcc) – Try It Online")
### Version closer to \$\frac{1}{10000}\$
For a pseudorandomness as close to \$\frac{1}{10000}\$ as possible:
# [C (gcc)](https://gcc.gnu.org/), 79 bytes
```
f(){long p=0,m=1e4,i;for(i=m;i--;)p+=rand();printf("Min%sraft",p%m?"ec":"ce");}
```
[Try it online!](https://tio.run/##PY1NCsMgFIT3nuLxIKAkQkq7qpWeoDfoRqwGIb6ICXQRcvVa@zubYYaPGSsHa0vxXKzjRAMk3XdR79yhC8pPmQcdVZBSidTqbOjGhUo50OI5XgI1czZ@wS418YzO4hGtQ6G2UgmIJhAXbGVQVbeAv1oCDb2qdoJ99bYlAR/kjdX9f/gdXQm/7ca28rB@NMNc5P0J "C (gcc) – Try It Online")
[Answer]
# [Taxi](https://bigzaphod.github.io/Taxi/), 632 bytes
```
Go to Heisenberg's:W 1 R 3 R 1 L.Pickup a passenger going to Divide and Conquer.1073741824e-4 is waiting at Starchild Numerology.Go to Starchild Numerology:N 1 L 3 L 1 L 3 L.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:W 1 R 3 R 1 R 2 R 1 R.Pickup a passenger going to Trunkers.Go to Trunkers:E 1 R 3 R 1 L.Pickup a passenger going to The Underground.Go to The Underground:E 1 R 2 L.Switch to plan A if no one is waiting.Minecraft is waiting at Writer's Depot.[A]Minceraft is waiting at Writer's Depot.Go to Writer's Depot:N 3 L 2 L.Pickup a passenger going to Post Office.Go to Post Office:N 1 R 2 R 1 L.
```
[Try it online!](https://tio.run/##lZFBT8MwDIX/im87EdGu0lBvE0NwKGPahnZAHELqttaKU5KUwa8vKW2lFRCDQxTFfvn0/OzkGzXNtQan4QbJIj@hySc23kEAa5j6E0AiVqT2dQUSKmm9JkcDuSbO228LeqUUQXIKl5pfajQiOJ9NZ1FwEUZ4FgFZOEhyrVw62DhpVEFlCsv6GY0udf4uOgM/teJla8AbSYb7v2Y69vfGaMQ1hN39K31rat6jsT1zeMZXfw5rWyDcc@ozNrrmdACNqz0v9KzNgZwqWk1VSoY5UAasQTMexSpuiVEZmbkvWe8MOTQTCwustBMP80evVHha2dkaF/0m2i2EJyZcaevgLstIYY85qnxuc8g6EU3zAQ "Taxi – Try It Online")
There are two sources of randomness in Taxi: **Heisenberg's** (which holds a random integer passenger), and **Firemouth Grill** (which can hold any number of passengers, who are picked up in a random order).
This program uses **Heisenberg's** to grab a random number, which will be used to choose one of two strings randomly.
Here is the basic control flow of the program:
* Go to **Heisenberg's** and grab a random integer, in the range of \$[0, 2^{31}-1]\$. (\$2^{31}-1\$ is `RAND_MAX` in C++, and Taxi uses C++'s random functions.)
* Pick up the value `1073741824e-4` (that's \$\frac{2^{31}}{2 \times 10000}\$) from **Starchild Numerology**.
* Drop off both passengers at **Divide and Conquer**, giving us a result of \$\frac{n}{2^{31}} \times 2 \times 10000\$, which is a double in the range \$[0, 2 \times 10000)\$. (We use this range instead of \$[0, 10000)\$ because we will output `Minceraft` when this number is either 0 or 1.)
* Bring this result to **Trunkers**, which chops off the fractional part. (The range is still \$[0, 2 \times 10000)\$.)
* Bring this result to **The Underground**. One of two things will happen:
* + A passenger will be returned, which means that our number was greater than 1 (which has a \$\frac{2 \times 10000 - 2}{2 \times 10000}\$ chance of occurring). Do nothing.
* + No passenger will be returned, which means that our number was either 0 or 1 (which has a \$\frac{2}{2 \times 10000}\$ chance of occurring). Declare the value `"Minceraft"` at **Writer's Depot**.
* Declare the value `"Minecraft"` at **Writer's Depot**.
* Pick up the first passenger waiting at **Writer's Depot**. (If both `"Minecraft"` and `"Minceraft"` are waiting, `"Minceraft"` will be picked up, because it was waiting there first.)
* Drop off this passenger at the **Post Office**, outputting the string and (for purposes of Code Golf) ending the program.
# [Taxi](https://bigzaphod.github.io/Taxi/), 691 bytes
```
1e4 is waiting at Starchild Numerology.Go to Starchild Numerology:W 1 L 2 R 1 L 1 L 2 L.Pickup a passenger going to The Underground.Minceraft is waiting at Writer's Depot.Go to Writer's Depot:E 1 L 2 R.[A]Pickup a passenger going to Cyclone.Go to Cyclone:N.Pickup a passenger going to Firemouth Grill.Pickup a passenger going to Firemouth Grill.Go to Firemouth Grill:S 1 L 2 L 1 R.Go to Fueler Up:E 1 L.Go to The Underground:N.Switch to plan B if no one is waiting.Pickup a passenger going to The Underground.Minecraft is waiting at Writer's Depot.Go to Writer's Depot:N 3 L 2 L.Switch to plan A.[B]Go to Firemouth Grill:S 1 R.Pickup a passenger going to Post Office.Go to Post Office:E 1 R.
```
[Try it online!](https://tio.run/##nVFLb4MwDP4rvu0WqdtO3No9eulYBat6qHqIggnW0hgFo66/ntECUoc2pO7k5LPl72HRX9Q0M3wEquCoSchb0AKp6GAKchnE9QEDO7YntWQQ/rUVbWEGK7iH5FK790qtyXzWJWgodVWhtxjA8pmhXfNRIGx8hsEGrn2m3sgbDDqXkZJtIMFwV8Ezliy9hp9g9DKwq918P0X6dDKOPfZb@l8UTwp9pYAHrqWAZSDnbprteEZolA4BtTUZZmp07aZN2Znp0VFIrdL0SGKKc6902sMCKAfP0Nq4yu3W4NH8M/gYHvpTj3TN1W6x/9t9MqlwzZXAe56TGS51hVzySVTTfAM "Taxi – Try It Online")
This program uses **Firemouth Grill** to hold thousands of "Minecraft" and "Minceraft" strings to choose from randomly.
Here is the basic control flow of the program:
* Pick up the value `1e4` from **Starchild Numerology** to use as a counter.
* Declare the value `"Minceraft"` at **Writer's Depot** and go there (but don't pick it up yet).
* Repeat these steps:
* + Pick up the string currently at **Writer's Depot**, and clone it at **Cyclone**. (Having two strings along for the ride will earn us extra gas money!)
* + Take both clones, and drop them off at **Firemouth Grill**.
* + Take our counter, and drop it off at **The Underground**. One of two things will happen:
* + - A passenger will be left waiting, which was 1 less than our previous counter. Pick up this new counter, and declare the value `"Minecraft"` at **Writer's Depot** and go there. At this point, repeat the previous steps.
* + - No passenger will be left waiting, which means that our counter is now 0 and we are done.
* Go to **Firemouth Grill**, and pick up a passenger. It will most likely be `"Minecraft"`, but there's a 1/10000 chance it will be `"Minceraft"`.
* Drop off this passenger at the **Post Office**, outputting the string and (for purposes of Code Golf) ending the program.
# [Taxi](https://bigzaphod.github.io/Taxi/), 849 bytes
```
Go to Fueler Up:W 1 R.Switch to plan B.[A]Go to Fueler Up:E 2 L.[B]Go to Heisenberg's:N 3 R 1 L.Pickup a passenger going to Cyclone.Go to Cyclone:N 1 L 3 L.Pickup a passenger going to Magic Eight.Pickup a passenger going to Cyclone.Go to Cyclone:N 1 R 3 R 1 R.Pickup a passenger going to Equal's Corner.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:N 1 R.2e4 is waiting at Starchild Numerology.Go to Starchild Numerology:N 1 R.Pickup a passenger going to Magic Eight.Go to Magic Eight:W 1 R 2 R 1 R.Switch to plan A if no one is waiting.Pickup a passenger going to The Underground.Go to The Underground:E 2 L.Switch to plan C if no one is waiting.Minecraft is waiting at Writer's Depot.[C]Minceraft is waiting at Writer's Depot.Go to Writer's Depot:N 3 L 2 L.Pickup a passenger going to Post Office.Go to Post Office:N 1 R 2 R 1 L.
```
[Try it online!](https://tio.run/##nVLLboMwEPyVveVmqbSn3BJK2wNJI9IoB5SDaxazKrWpMUrz9dQEVyIooo@jZ3dm1rtj@Se17aMGq@GhwRIN7Kr5Hm4gYdsjWVF0larkCpYsXRzGnREEELN06QtPSDWqVzRyVs/XcAuJU4rZhsRbUwGHiteuLh1XalKyo4QnUWqFrBfwL8d1PMef5q64JAERycL@0yPxMyaT/Oij4eWshlAbheYvrb3jJdgbswDvgGo4crIdl1vYWm5EQWUG6@YdjS61PHmFayWv89sF9UIDpD@zO2By7dwLoByUBrepwZiTbi8Fwk5l7vpGNyrzjiPUR2bkFl53W5FCYXhuR5vaG7Jo3EbvsdKWpeHBdQr8ubMf6RI8BzU@TzX1u42uLTznOYnvIA0QH6bAB75tvwA "Taxi – Try It Online")
This was my first instinct. It also uses **Heisenberg's** to generate a random integer within the range \$[0, 2 \times 10000)\$, but it does so by repeatedly generating a random number until it is within this range. The taxi has to stop at **Fueler Up** to refill its gas tank, and it has to clone passengers at **Cyclone** and drop the clones off at **Equal's Corner** to make enough money to re-generate random numbers for as long as necessary, but otherwise, the functionality is the same as the 632-byte program.
It doesn't depend on the specifics of C++, but it *does* usually take longer to execute, because generating a small enough random number is rarer. If anyone can improve this one, be my guest.
[Answer]
# [Clojure](https://clojure.org/), 42 bytes
```
#(str"Min"(if(<(rand)1e-4)"ce""ec")"raft")
```
[Try it online!](https://tio.run/##S87JzyotSv2vUVCUmVeioPFfWaO4pEjJNzNPSSMzTcNGoygxL0XTMFXXRFMpOVVJKTVZSVOpKDGtREnzv6bmfwA "Clojure – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~45~~ ~~44~~ 43 bytes
```
`if`(runif(1)<1e-4,"Minceraft","Minecraft")
```
[Try it online!](https://tio.run/##K/r/PyEzLUGjqDQvM03DUNPGMFXXREfJNzMvObUoMa1ECcxOTQazNf//BwA "R – Try It Online")
Boring, but shorter than any more-interesting attempt that I've tried so far...
---
# [R](https://www.r-project.org/), 42 bytes ~~(p=0.000101)~~ p=1 in 10000.5
*Edit: much closer to exactly 1 in 10000 (for the same bytes) thanks to Robin Ryder*
```
`if`(rexp(1)>1e-4,"Minecraft","Minceraft")
```
[Try it online!](https://tio.run/##K/r/PyEzLUGjKLWiQMNQ084wVddER8k3My81uSgxrUQJzE5OBbM1//8HAA "R – Try It Online")
Outputs "Minecraft" if an exponentially-distributed random variable is greater than 1e-4.
The exponential distribution is governed by a parameter - lambda - that defaults to 1 in the [R](https://www.r-project.org/) `rexp()` function. This gives cumulative p(up to x)=1-exp(-lambda\*x), equal to 9.9995e-05 with x=1e-4 and lamda=1, which is pretty close to 1 in 10000 (actually 1 in 10000.5).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 17 bytes
```
MinＰceraft¿‽×χφec
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvREPJNzNPSdOay7c0pySzACKUnFqUmFYCEs1MU9AISsxLyc/VCMnMTS3WMDTQUTA0MDDQ1NRUgBqQmgxU@f//f92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Min
```
Print `Min`.
```
Ｐceraft
```
Print `ceraft` without moving the cursor.
```
¿‽×χφ
```
If a random number in the range `[0..10000)` is nonzero, then...
```
ec
```
... correct it to `ec`.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 29 bytes
```
ce9999*$(ec
L@$`..
Min$&raft
```
[Try it online!](https://tio.run/##K0otycxLNPz/nys51RIItFQ0UpO5fBxUEvT0uHwz81TUihLTSv7/BwA "Retina – Try It Online") Explanation:
```
ce9999*$(ec
```
Insert `ce` and `9999` copies of `ec`.
```
L@`..
```
Select one of the pairs of letters at random....
```
L$`
Min$&raft
```
... and wrap it between `Min` and `raft`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 17 bytes
```
’£Ì³±’œ4°LΩΘ5!*è™
```
[Try it online!](https://tio.run/##ASoA1f9vc2FiaWX//@KAmcKjw4zCs8Kx4oCZxZM0wrBMzqnOmDUhKsOo4oSi//8 "05AB1E – Try It Online")
```
’£Ì³±’                -- "minecraft"
      œ               -- permutations: ["minecraft", "minecratf", ...]
       4°LΩ           -- random integer in the range 1..10000
           Θ          -- 1 if it’s equal to 1, 0 otherwise
            5!*       -- multiply by 5! (120)
               è      -- index into the list of permutations
                ™     -- titlecase
```
[Answer]
# APL, 26 bytes
```
'Min','raft',⍨'ec'⌽⍨1=?1E4
```
Saved 1 byte thanks to Adam
[Answer]
# Minecraft, 226 bytes.
```
/scoreboard objectives add d dummy
/scoreboard players set c d 2147054151
/execute store result score s d run seed
/execute if score s d < c d run tellraw @s "Minecraft"
/execute if score s d >= c d run tellraw @s "Minceraft"
```
(Includes a trailing newline, to run the final command)
I saw [the other Minecraft answer](https://codegolf.stackexchange.com/a/224504/110376) by [Okx](https://codegolf.stackexchange.com/users/26600/okx) and had some suggestions. I would've put them in the comments of the other response, but I figured I changed it enough for its own submission, and [another CGSE member said it's fine](https://chat.stackexchange.com/transcript/message/63155893#63155893) so whatever.
I'm only just now noticing the only change I made was using /seed. Ah, well. The things you learn when you have five ideas for improvements and four of them don't work.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 38 bytes
```
"Min$(('ec','ce')[!(random 1e4)])raft"
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X8k3M09FQ0M9NVldRz05VV0zWlGjKDEvJT9XwTDVRDNWsygxrUTp/38A "PowerShell – Try It Online")
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 80 bytes
```
iMin<Esc>:r!echo $RANDOM
C<c-r>=<c-r>"%10000
<esc>:s/^0\n/ce
:s/\d\+/ec
kgJAraft
```
[Try it online!](https://tio.run/##K/v/P9M3M8/GtTjZzqpIMTU5I19BJcjRz8Xfl8vZJlm3yM4WTCqpGhoAAZdNKkhhsX6cQUyefnIqF5AZkxKjrZ@azJWd7uVYlJhW8v//f90yAA "V (vim) – Try It Online")
Generate a random no. in 0-9999, and then replace 0 with ce and anything else with ec.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~18~~ 17 bytes
```
“ẹ?ŀɼƲṬ`Ỵȧ»ȷ4XỊịḲ
```
[Try it online!](https://tio.run/##AS4A0f9qZWxsef//4oCc4bq5P8WAybzGsuG5rGDhu7TIp8K7yLc0WOG7iuG7i@G4sv// "Jelly – Try It Online")
Full program.
-1 byte thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)!
## How it works
```
“ẹ?ŀɼƲṬ`Ỵȧ»ȷ4XỊịḲ - Main link. Takes no arguments
“ẹ?ŀɼƲṬ`Ỵȧ»       - Compressed string "Minceraft Minecraft"; Call that S
           ȷ4     - 10000
             X    - Random integer between 1 and 10000
              Ị   - Is that equal to 1?
                Ḳ - Split S on spaces
               ị  - Index into the split S
```
[Answer]
# [J](http://jsoftware.com/), 28 25 bytes
```
'Minecraft'120&A.~0=?@1e4
```
[Try it online!](https://tio.run/##y/pvqWhlGGumaGWprs6lpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/1X0z81KTixLTStQNjQzUHPXqDGztHQxTTf5rcqUmZ@QrpCkA9VOZ9R8A "J – Try It Online")
-3 thanks to Bubbler
*Note: J does not allow 0-argument functions, but this function ignores it's argument, which is the J equivalent*
To see this work, change `1e4` to `2` in the TIO, which will make the letter swap happen 50% of the time.
* `0=?@1e4` Does a random number between 0 and 9999 inclusive equal 0? Returns `1` one in 10000 times.
* `120&A.` Transposes the requires letters.
* Conditional execution at rate according to step 1 happens as a result of the way `&` works when invoked dyadically.
## alternative 1, 27 bytes
```
4|.'raftMin','ec'|.~0=?@1e4
```
[Try it online!](https://tio.run/##y/pvqWhlGGumaGWprs6lpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/TWr01IsS00p8M/PUddRTk9Vr9OoMbO0dDFNN/mtypSZn5CukKair/wcA "J – Try It Online")
Rotate `|.` the string `'ec'` with probability 1/10k, then append it to the string `'raftMin`, then rotate the result by 4.
## alternative 2, 28 bytes
```
'Minecraft'C.~3<@,4#~0=?@1e4
```
[Try it online!](https://tio.run/##y/pvqWhlGGumaGWprs6lpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/1X0z81KTixLTStSd9eqMbRx0TJTrDGztHQxTTf5rcqUmZ@QrpCmoq/8HAA "J – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~62~~ 61 bytes
-1 byte thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor)!
```
from random import*
print'Min%sraft'%'ceec'[random()>1e-4::2]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocRUUZeaVqPtm5qkWFyWmlairqienpiarR0OUaWjaGabqmlhZGcX@/w8A "Python 2 – Try It Online")
If a probability of \$\left({92 \over 256}\right)^9 \approx 0.0000999841\$ to print *Minceraft* is fine, 59 bytes is possible:
```
import os
print'Min%sraft'%'ceec'[max(os.urandom(9))>91::2]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PzO3IL@oRCG/mKugKDOvRN03M0@1uCgxrURdVT05NTVZPTo3sUIjv1ivtCgxLyU/V8NSU9PO0tDKyij2P1iHgrqqnqFBmrqqhoalkZ6@kamZppaWpeZ/AA "Python 2 – Try It Online")
---
# [Python 2](https://docs.python.org/2/), 63 bytes
```
from random import*
print'Min%xraft'%(236-30*0**randrange(1e4))
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocRUUZeaVqPtm5qlWFCWmlairahgZm@kaG2gZaGmBlAJxeqqGYaqJpub//wA "Python 2 – Try It Online")
[Answer]
# [Swift](https://developer.apple.com/swift/), ~~55~~ 53 bytes
```
print(.random(in:1...1e4)<2 ?"Minceraft":"Minecraft")
```
[Try it online!](https://tio.run/##Ky7PTCsx@f@/oCgzr0RDrygxLyU/VyMzz8pQT0/PMNVE08ZIwV7JNzMvObUoMa1EyQrETk0GszX//wcA "Swift – Try It Online")
This is also my first Code Golf post.
Thanks to [@Dingus](https://codegolf.stackexchange.com/users/92901/dingus) for getting taking off 2 bytes!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~19~~ 18 bytes
```
„ecтnиćRªΩ”–·ÿraft
```
[Try it online!](https://tio.run/##ASkA1v9vc2FiaWX//@KAnmVj0YJu0LjEh1LCqs6p4oCd4oCTwrfDv3JhZnT//w "05AB1E – Try It Online")
[Run 10000 times](https://tio.run/##yy9OTMpM/W9oAARu/x81zEtNvtiUd2HHkfagQ6vOrXzUMPdRw@RD2w/vL0pMKwHKzz20Quc/AA)
```
„ec      push string "ec"
т        push 100
n        squared, 10000
и        repeat, push ["ec"]*10000
ć        head extract
R        reverse
ª        append
Ω        choose random element
”–·ÿraft push "Min" + tos + "raft", which is implicitly outputed
```
[Answer]
# Mathematica, ~~48~~ ~~44~~ ~~43~~ 41 bytes
```
If[Random[]<.1^4,"Minceraft","Minecraft"]
```
Here's a simple unit test which found a bug in my first version.
```
Table[If[Random[]<.1^4,"Minceraft","Minecraft"], {ix, 10^6}] // Counts
```
And the result:
```
<|"Minecraft" -> 999909, "Minceraft" -> 91|>
```
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), ~~100~~ ~~97~~ 81 bytes
```
"tfarec"v
77+:v>0#<
v*2\_v
?1v0:#
^#< ^-1\$#+
+55:$<  |`-1*:*:
>:#,_@ |<
^ "Min"<
```
[Try it online!](https://tio.run/##BcE7CoAwDADQPacIjVOrYAURQlAv4A2k/qji4iCaybvX99a4v9cRUzLPvtxxMwpN41jbkgTUVuOk0HktmSCQYCj8mJEDV9ecCeI3F96yZWiZ8qnHTyCgGc7LSEo/ "Befunge-93 – Try It Online")
Uses rejection sampling to generate a random integer between 0 and 9999 inclusive, and then swaps the letters if that number is 0.
I abused some coincidences that arose in my code to golf it.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~27~~ ~~20~~ 18 bytes
```
`↔ṅ`₴k2ṁċ[`ec`|`ce`]₴`r…ż`,
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJg4oaU4bmFYOKCtGsy4bmBxItbYGVjYHxgY2VgXeKCtGBy4oCmxbxgLCIsIiIsIiJd)
Edit: this is actually 7 less bytes, at only 20:
```
k2ṁ[`↓∑ġ¬`|`↔ṅ⇩ṡ…ż`]
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrMuG5gVtg4oaT4oiRxKHCrGB8YOKGlOG5heKHqeG5oeKApsW8YF0iLCIiLCIiXQ==)
Edit 2: Thanks to [@emanresu A](https://codegolf.stackexchange.com/users/100664/emanresu-a?tab=profile), this has been shortened to 18 bytes.
```
k2ṁ[`↓∑ġ¬`|`↔ṅ⇩ṡ…ż
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrMuG5gVtg4oaT4oiRxKHCrGB8YOKGlOG5heKHqeG5oeKApsW8IiwiIiwiMTEiXQ==)
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 43 bytes
```
x=(ce ec);echo Min${x[RANDOM%9999?1:0]}raft
```
[Try it online!](https://tio.run/##S0oszvj/v8JWIzlVITVZ0zo1OSNfwTczT6W6IjrI0c/F31fVEgjsDa0MYmuLEtNK/v8HAA "Bash – Try It Online")
`RANDOM%9999` has a range of [0,9999], and in bash `0` evaluates to false, so the ternary works as expected. Supposedly, the `$RANDOM` function has an "[approximately](https://stackoverflow.com/questions/15939495/is-the-bash-function-random-supposed-to-have-an-uniform-distribution) linear distribution", but I haven't proved that with a million iterations. Hat-tip to the [Zsh solution](https://codegolf.stackexchange.com/a/224552/15940).
[Answer]
# JavaScript, ~~51~~ 44 bytes
```
_=>`Min${Math.random()*1e4>1?'ec':'ce'}raft`
```
[try it online](https://tio.run/##BcFRDkQwEADQy2zSlqyo@FrKCZyBSU0ZoSPV@Nk4e723wQ2XDXTGr@cZkzNpNN00kP/8B4hrEcDPfEiVaaw73Qu04icsiieAi1NyHCSZsqFWY9VQnivL/uIdi50X6aRS6QU)
That's a lotta bytes for such a simple task...
*-7 thanks to the OP*
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 59 bytes
```
printf "%0.sMinecraft\n" {0..9999}|sed '1s/ec/ce/'|shuf -n1
```
[Try it online!](https://tio.run/##S0oszvj/v6AoM68kTUFJ1UCv2DczLzW5KDGtJCZPSaHaQE/PEghqa4pTUxTUDYv1U5P1k1P11WuKM0rTFHTzDP//BwA "Bash – Try It Online")
Change 9999 to 1 to see it work with 50% probability.
Repeats the line "Minecraft" 10,000 times. Changes the first line only to "Minceraft". Shuffles the lines randomly and returns the first.
[Answer]
# [Factor](https://factorcode.org/), ~~40~~ 38 bytes
```
1e-4 [ "Minceraft"] [ "Minecraft"] ifp
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQnJ@blJmXCBQp1itKzEvJz1XIzFew/m@YqmuiEK2g5JuZl5xalJhWohQL5aYmQ7mZaQX/C4oy80r@AwA "Factor – Try It Online")
*-2 bytes thanks to @Bubbler!*
Factor has a version of `if` called `ifp` that calls either quotation depending on a probability.
There is also an interpolating version that is slightly longer:
```
1e4 random 1 < "ce""ec"? [I Min${}raftI]
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~35~~ 34 bytes
```
$><<"Min#{rand<1e-4?:ce: :ec}raft"
```
[Try it online!](https://tio.run/##KypNqvz/X8XOxkbJNzNPubooMS/FxjBV18TeKjnVSsEqNbm2KDGtROn/fwA "Ruby – Try It Online")
Thanks to Dingus for a saved byte.
[Answer]
# Excel, ~~41~~ 40 bytes
*-1 byte thanks to MarcMush*
```
="Min"&IF(RAND()<0.1^4,"ce","ec")&"raft"
```
I tried typing 0.0001 as 1E-4 to save two bytes. Excel changes it to 0.0001.
]