# Basic sort, with annoying bug

## Python 3, 36 bytes

### Bug-free version, 37 bytes

```
lambda l:sorted(l,reverse=l[-9:]==[])
```

Try it online!

### Annoying version, 36 bytes

```
lambda l:sorted(l,reverse=l[9:]==[])
```

Try it online!

This depends on the input and therefore does not qualify for the bonus.

It has a probability of around 2% to fail. It fails when the input length is lower then 10.

Combined with LyricLy's answer this gets 34 bytes:

```
lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]
```

## 05AB1E, 5*0.9 = 4.5 bytes

**Working solution**

```
{TLΩi
```

Try it online!

**Explanation**

```
{ # sort input
TL # push the range [1 ... 10]
Ω # pick a random number in the range
i # if true (equal to 1), do nothing
```

**Solution containing the bug**

Gives the wrong solution 10% of the time (independent on input).

```
{TLΩiR
```

Try it online!

**Explanation**

Same as the working solution, except it reverses the list if the number picked is true.

## Jelly, 7 * (100% - 10%) = 6.3 bytes

```
Ṣ¹⁵X:¤¡
```

Try it online!

Buggy version:

```
ṢẊ⁵X:¤¡
```

Try it online!

In both links, there's a test harness that will run the code 100 times, each time with the list you give as the argument, and then return the results.

The probability of each input length is:

```
0.1 - 0.1/(length!)
```

So for length 1 there's a 0% probability, for length 2 5%, for length 3 8.83̅%, for length 4 9.583̅% etc. until length ∞ which has a 10% probability.