[Question]
  [
Create a cat program, a.k.a a program that takes an input and prints it.
...Except, the program will randomly take characters away from your input and print that instead.
Each character in the input should have generally equal odds to be removed with the program, though, as it is hard to make that, the odds for each character can vary by 10% at most.
Your program should take the input, then randomly remove characters from the input, then print that version again. (You can print with trailing newlines or other characters in case your language has to print newlines.)
If the input was `BOOOWL`, it shouldn't remove all Os with an equal chance: each character (not unique) should be considered, so instead of every O combined having a 1/5 chance (for example), each O should have a 1/5 chance, so, instead of there being a 1/5 chance of `BWL`, there should be a 1/5 chance of `BOWL`, `BOOWL`.
Input is restricted to STDIN or closest equivalent.
Each character *must* have a minimum of 10% and a maximum of 30% chance to be removed.
Each character's odds should be calculated individually. 
You can use any component of your language supporting random actions, be it functions or something other.
Output must be through STDOUT or the closest equivalent. If your language does have STDOUT, do not output in any other way. If your language cannot output strings as text, use closest equivalent (C's character array output's OK here).
This is code golf. Shortest program wins.
  
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-f`](https://codegolf.meta.stackexchange.com/a/14339/), 2 bytes
```
5ö
```
The `-f` flag "runs the program on each element in the first input, outputting an array of those that return a truthy value." `5ö` returns a random number between 0(inclusive) and 5(exclusive). Like JavaScript, 0 is falsy in Japt.
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWY&code=NfY&input=IkJvd2wi)
[Answer]
# [Python 3](https://docs.python.org/3/), 63 bytes
```
from random import*
for c in input():print(end=c[random()<.2:])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P60oP1ehKDEvBUhl5hbkF5VocaXlFykkK2TmAVFBaYmGplVBUWZeiUZqXoptcjRErYamjZ6RVazm//9O/uE@AA "Python 3 – Try It Online")
# [Python 2](https://docs.python.org/2/), ~~67~~ 65 bytes
```
from random import*
print''.join(c for c in input()if.8>random())
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocRUUZeaVqKvrZeVn5mkkK6TlFykkK2TmAVFBaYmGZmaanoUdRIuGpub//0pO/uE@SgA "Python 2 – Try It Online")
Each character has a 20% chance of beeing dropped.
Different approach, same length:
```
from random import*
print''.join(c[random()<.2:]for c in input())
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P60oP1ehKDEvBUhl5hbkF5VocRUUZeaVqKvrZeVn5mkkR0NkNTRt9IysYtPyixSSFTLzgKigtERDU/P/fyUn/3AfJQA "Python 2 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 4 bytes
```
ΦＳ‽⁵
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMtM6cktUjDM6@gtCS4BCiUrqGpoxCUmJeSn6thqqmpaQ1SmZ9elJibC5RUCCitqspJLVZQU3DOT0lVcM/PSeP6r1uWAwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 Ｓ      Input a string
Φ       Filter where nonzero
  ‽⁵    Random number 0..4
        Implicitly print
```
You can use any number from `4` to `10` to get chances of `25%` to `10%` respectively.
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), 11 bytes
```
>#@~3j4???,
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//@3U3aoM84ysbe31/n/Pzk/JVUhPT8nDQA "Befunge-98 (PyFunge) – Try It Online")
Each character has a 25% chance of being removed. This decision is made at the three `?` instructions.
`?` sets the program counter to one of the four directions, with equal probability. In this case, up & down wrap back around to the same instruction, so we can ignore those as options.
There are two ways out of the forest of `?`s: to the right (output) and to the left (no output). This situation is symmetric, so if starting from the middle `?`, there is a \$p\_2 = 1/2\$ chance of outputting. The chance of outputting if starting from the right `?` is \$p\_3 = 1/2 \* 1 + 1/2 \* p\_2 = 3/4\$. Therefore, after reading a character, we jump to the rightmost `?` to determine whether or not to output.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 23 bytes
Generates an array of the same size as the input (strings in Octave are character arrays), checks each of the random numbers whether it is greater than `0.2` and then uses logical indexing to extract the characters at the corresponding positions.
```
@(s)s(rand(size(s))>.2)
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQaNYs1ijKDEvRaM4syoVyNO00zPS/J@SWVygkZhXrKHk6OTs4uqmpKn5HwA "Octave – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 5 bytes
```
5X’µƇ
```
[Try it online!](https://tio.run/##y0rNyan8/9804lHDzENbj7X////fOT8lVSE9PydNIa2kHAA "Jelly – Try It Online")
A monad which takes a Jelly string as its argument and returns the processed Jelly string. When used as a full program implicitly prints the output. Each character has a 20% chance of being removed. 
## Explanation
```
   µƇ | Filter using the following as a monad for each character:
5X    | - Random number between 1 and 5
  ’   | - Decreased by 1
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 3 bytes
Each character has a 1 in 5 chance of being removed. The `5` can be changed to anything between `4` & `9`, inclusive, or `A` for `10` to change the odds.
```
Æ5ö
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=xjX2&input=IkJvd2wi)
```
Æ5ö     :Implicit input of string
Æ       :Filter by
 5ö     :  Random integer in the range [0,5), with 0 being falsey
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~8~~ 5 bytes
```
sfO4Q
```
[Try it online!](https://tio.run/##K6gsyfj/vzjN3yTw/3@lxKTklFQlAA "Pyth – Try It Online")
```
sfO4Q   Implicit: Q=eval(input())
 f  Q   Filter characters of Q where the following is truthy:
  O4      Random number in the range [0-4)
          Any non-zero value is truthy, so this will drop characters 25% of the time
s       Concatenate into string, implicit print
```
---
Previous version, 8 bytes:
```
s*Vm!!O4
```
[Try it online!](https://tio.run/##K6gsyfj/v1grLFdR0d/k/3@lxKTklFQlAA "Pyth – Try It Online")
```
s*Vm!!O4QQ   Implicit: Q=eval(input())
             Trailing QQ inferred
   m    Q    Map each character in Q using:
      O4       Choose random integer in [0-4)
    !!         Logical NOT twice - maps 0 to 0, anything else to 1
             The result is a list of 0s and 1s, with 0 having 25% chance to appear
 *V      Q   Vectorised multiplication of the above with Q
s            Concatenate into string, implicit print
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 24 bytes
```
Select[RandomReal[]>.2&]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7Pzg1JzW5JDooMS8lPzcoNTEnOtZOz0gt9n9AUWZeSbSyrl2ag3NGYlFicklqUbGDcmydS36dqZq@QzWXkpN/uI8SV@1/AA "Wolfram Language (Mathematica) – Try It Online")
Takes a list of characters as input. Each character has a `.2` chance to be removed.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~5~~ 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ʒ₄Ω≠
```
-1 byte thanks to *@Grimy*.
[Try it online](https://tio.run/##yy9OTMpM/f//1KRHTS3nVj7qXPD/v1N@eQ4A) or [run the same program 10 times](https://tio.run/##yy9OTMpM/R/i9v/UpEdNLedWPupc8L9W579TfnkOAA).
Each character has a 25% change of being dropped.
**Explanation:**
```
ʒ     # Filter the characters of the (implicit) input-string by:
 ₄    #  Push 1000
  Ω   #  Pop and push a random digit from it
   ≠  #  And check that it's NOT 1 (!=1)
      # (after which the result is output implicitly)
```
`≠` could also be `_` (`==0`).
[Answer]
# [MATL](https://github.com/lmendo/MATL), 9 bytes
```
t&n&r.2>)
```
Exaplanation:
```
t         implicitly take input and duplicate it
 &n       compute the size of the input and...
   &r     generate a random array of that size
     .2>  check which entries of that array are greater than 0.2
        ) and use the result using logical indices to extract certain characters of the input
```
[Try it online!](https://tio.run/##y00syfn/v0QtT61Iz8hO8/9/dUMjYxNTs8Sk5JTUNHUA "MATL – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 20 bytes
```
u$w\A|UDw@?;...>o._U
```
[Try it online!](https://tio.run/##Sy5Nyqz4/79UpTzGsSbUpdzB3lpPT88uXy8@9P//pPzyHAA "Cubix – Try It Online")
Longer than I had hoped as I had a number of no-ops that I can't seem to get rid of. The chance to drop a character is 25%. I assume this is okay.
```
    u $
    w \
A | U D w @ ? ;
. . . > o . _ U
    . .
    . .
```
[Watch it run](https://ethproductions.github.io/cubix/?code=dSR3XEF8VUR3QD87Li4uPm8uX1U=&input=Ym93bA==&speed=20)
Brief explanation:
* `A|A` this initialises the the stack, Input all, reflect back, Input all (just an EOI -1)
* `;?` pop to of stack, test for EOI (-1).
* `_?@` if negative, reflect back into test and end on halt
* `$D` jump the `\` into the random direction setter.
	+ from the direction setter, 3 direction lead to the `o` for output then back into the loop, one misses the `o` in it's path and goes straight to the loop.
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), ~~10~~ 9 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function. Each character has exactly 20% chance of being removed.
```
⊢⌿⍨4≥∘?5¨
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfyf9qhtgsb/R12LHvXsf9S7wuRR59JHHTPsTQ@t@K/J9ahvKlA6TT0kI1UhObFEIbEkVaEyv7RIITOvoBTITU/MzFNU/w8A "APL (dzaima/APL) – Try It Online")
`5¨` zero for each character
`?` random integer range 1–5 for each character
`4≥` Boolean mask for those integers that are less than or equal to 4
`⊢⌿⍨` filter the argument using that mask
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 15 bytes
```
/./_?(`.
```
[Try it online!](https://tio.run/##K0otycxLNPz/X19PP95eI0GPCwL@/w8oyk8vSszNzcxLVwgorarKSS1WUFNwzk9JVXDPz0kDAA "Retina – Try It Online") Explanation:
```
/./_
```
Process each character individually.
```
?(`
```
Perform a substitution at random. The first substitution deletes the character, while the other three leave it unchanged, thus giving a `25%` chance of deleting the character. This can be decreased as necessary by appending additional pairs of newlines.
[Answer]
# [R](https://www.r-project.org/), ~~32~~ 23 bytes
```
function(x)x[rt(x,3)<1]
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQrMiuqhEo0LHWNPGMPZ/mkZxSVFxQU5miYaSR2pOTr5CeX5RToqiko6CkpJmdLRhbKzmfwA "R – Try It Online")
A function taking a character vector as input and returning a processed character vector. Each character has a 20% chance of being removed. 
Thanks to @Roland and @Giueseppe for helping save 7 bytes, and @JDL for a further 2!
[Answer]
# T-SQL 2012, 83 bytes
Looping through the input from right to left removing 0 or 1 character.
25% chance for each character getting removed.
```
DECLARE @i varchar(max)='The cat ate my homework'
DECLARE @ int=len(@i)WHILE @>0SELECT
@i=stuff(@i,@,str(rand()*2)/2,''),@-=1PRINT @i
```
Explanation:
> 
> `rand()*2` returns a float, which can't be used in the `stuff` command.
> 
> 
> The `str` converts this into a varchar after rounding to nearest whole number. The float is being converted to a varchar(which isn't allowed as third parameter in `stuff` either).
> 
> 
> This varchar has a 25% chance of being '2', 50% chance of being '1', 25% chance of being '0'. Dividing by 2, there is a 25% chance of result being 1. This division converts the varchar to an integer.
> 
> 
> Integer is the expected third parameter in `stuff` function.
> 
> 
> 
**[Try it online](https://rextester.com/FSYQ7693)**
[Answer]
# [J](http://jsoftware.com/), 10 bytes
```
#~5>6?@$~#
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/letM7czsHVTqlP9rcnEVpRaWZhalKqjnleamFmUmq3MVJeal5OdmVqWqq3NxpSZn5CtopCkZaioYGigoKxkoxCvoWKlnpObk5CuU5xflpKhz/QcA "J – Try It Online")
Similar to Adam's APL answer, though I actually wrote it before looking at his.
* `6.. $~ #` Take the length of input `#` and shape `$~` the number 6 into a list that long.
* `?@` Treat each six in that list as a die and roll `?` it.
* `>5` Is the die less than 5 (possible values are 0..5)? Use that boolean result to create a bit mask.
* `#~` Filter the input with that mask.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 18 bytes
```
s/./.2<rand&&$&/ge
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX09fz8imKDEvRU1NRU0/PfX/f0MjYxNTM3MLS4N/@QUlmfl5xf91CwA "Perl 5 – Try It Online")
Each character has a 20% chance of being dropped.
[Answer]
# Javascript, ~~46~~ ~~44~~ 51 bytes
```
i=>alert([...i].filter(c=>Math.random()>.2).join``)
```
+7 bytes because of the added STDOUT requirement
-2 bytes thank to Birjolaxew
---
original answer: 
44 bytes without the STDOUT requirement
```
i=>[...i].filter(c=>Math.random()>.2).join``
```
[Answer]
# [Scala](http://www.scala-lang.org/), ~~51~~ ~~46~~ 30 bytes
```
s=>s.flatMap(x=>if(math.random>.2)Some(x)else None)
```
[Try it online!](https://tio.run/##Lcs9DgIhEEDhnlNMtoKGwtJkSTyANusFRhhklb/AJK4xnh23sHrN97rFiKPcHmQZLNDGlF2HU63wEcKRB39cuK35Ppt/R59N1z4in7HKbTarlwk56IbZlWT0QS0lkdwUxU5wKZnUqPvKMUsvp2sgsMiATJDeEHb7Ku05KSW@Y/wA "Scala – Try It Online")
PS. Like in many other solutions, the probability of dropping char is 20%.
# Update:
-5 bytes by using String instead of Option[String] in flatMap
```
s=>s.flatMap(x=>if(math.random>.2)x+""else "")
```
30 bytes by using filter
```
s=>s.filter(x=>math.random>.2)
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 71 bytes
```
var y=new Random();foreach(var k in ReadLine())if(y.Next(5)<4)Write(k);
```
[Try it online!](https://tio.run/##Sy7WTS7O/P@/LLFIodI2L7VcISgxLyU/V0PTOi2/KDUxOUMDJJWtkJmnEJSamOKTmZeqoamZmaZRqeeXWlGiYappY6IZXpRZkqqRrWn9/79TfnkOAA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~43~~ 42 bytes
```
for(;''<$l=$argn[$i++];rand()%5&&print$l);
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKzV1W1UcmxVEovS86JVMrW1Y62LEvNSNDRVTdXUCooy80pUcjSt//938g/3@ZdfUJKZn1f8X9cNAA "PHP – Try It Online")
Each character has 20% of chance to be removed.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 50 bytes
This program has a 20% chance of dropping a letter. Unfortunately the random number generator isn't seeded so you get the same sequence on each run. Basically the only trick is inverting the input character to halt the loop on EOF.
```
main(c){for(;c=~getchar();rand()%5&&putchar(~c));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1mzOi2/SMM62bYuPbUkOSOxSEPTuigxL0VDU9VUTa2gFCJWl6ypaV37/39IRmaxAhAlKpSkFpf8S07LSUwv/q9bDgA "C (gcc) – Try It Online")
## [C (gcc)](https://gcc.gnu.org/), 64 59 bytes
Thanks to ceilingcat for the -5 bytes.
If you want the RNG seeded on each run.
```
main(c){for(srand(&c);c=~getchar();rand()%5&&putchar(~c));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1mzOi2/SKO4KDEvRUMtWdM62bYuPbUkOSOxSEPTGiyqqWqqplZQChGrS9bUtK79/z8kI7NYAYgSFUpSi0v@JaflJKYX/9ctBwA "C (gcc) – Try It Online")
[Answer]
# [Lua](https://www.lua.org), ~~69~~ 68 bytes
```
for c in io.lines(nil,1)do io.write(math.random()>.2 and c or '')end
```
[Try it online!](https://tio.run/##TY6xTsQwEET7@4pJFVvKWYLyCiiorjiuuC9Y4iVZLvYKZyOLrw9GSIhuZnbfaJaN9uMRN@aIiTMXMi0Br2oo/LlJabkpEt0Zo0ZG1XKXPA342Fb7O0l7pxw1hUMim8OvWVur0zWYJHbe7@9aMEIyRMMimVeXZRkefNSfpBYxdv9w55/CI5psUCP73nOO@36tbeYJ5zYlRy4D6syFESUifWGcqdBoXFZUzgaaSPJzd3ghO@HCWju4c59AeKNWTNb5bw "Lua – Try It Online")
Kinda straightforward, but seems to be shortest version: iterate over stdin char by char (with `io.lines`… that name is misleading), then based on random value either print one or empty string (e.g. nothing).
[Answer]
# Java
Non-terminating: 82 bytes
```
v->{for(int i;;i=System.in.read(),System.out.print(Math.random()<.2?"":(char)i));}
```
[Terminating (TIO): 105 bytes](https://tio.run/##ZY6xTsMwFEX3fMVTJ1uiFmLEpEx061SJBTG8OHbyUseObMdtifLtwSA2prPce88dMON@aC@bshgjnJAcLBW5pINBpeG4ZE8tGPb@g8wh9cFfI7zdlJ4SeSfXapobSwpiwlTwmx/LDjunQK77@AQMXfzfLJ4jGKi3vD8sGQO4@nyPSY@CnDQ@sPICSDpRLpLFxmrGD4@SaieCxpbxh7@4n5OYiiqxE6ZeBHStHxl/EU@vu90zUz0GTpzLdZOVEYa52Vouq3XdsFGtNl1Pw8WOzk8hpjlfb/evbw)
```
v->{var n=System.in;for(int i;n.available()>0;i=n.read(),System.out.print(Math.random()<.2?"":(char)i));}
```
[Answer]
# [Zsh](https://www.zsh.org/), 50 bytes
```
for c (${(s::)"$(<&0)"})
((RANDOM%5))&&echo -nE $c
```
[Try it online!](https://tio.run/##HY6xasMwFEX39xWXYBkJEtOli@mS0o5tobOgCPvZFjhPQXohpKXf7iod7xnOPd9l2bYpZQywzY8tfe92jX1qH9zu15G1n8f3l4838@hc2/KwJBzkFc2wbc9rODGiIgl0YQxBEeYQpes6Oq7XcCvgoFFmnG6Icr5oB/NliOiQMa1hrhCZw7j/d9Zx95ONUrRSpAnXqEu66B6175yj6OQoZIYwjzzinl2vC/cw3njvxWevnjz9AQ "Zsh – Try It Online")
Similar to RobLogic's answer, but following the input requirements more closely, and works for inputs with backslashes.
`"$(<&0)"` instead of `"<&0"` or `$(<&0)` because the first doesn't work in substitutions, and the second eats newlines. The `-nE` flags are necessary to prevent backslashes from being parsed as escape sequences, and to prevent newlines being inserted.
`echo -nE`
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 5 bytes
```
æƒ√∞*
```
[Try it online!](https://tio.run/##y00syUjPz0n7///wsmOTHnXMetQxT@v/f3WP1JycfB2F8vyinBRFdQA "MathGolf – Try It Online")
## Explanation
```
æ       foreach character...
 ƒ      random float in range [0,1)
  √     take square root (making P(x < 0.5) = 0.25)
   ∞    pop a, push 2*a
    *   repeat character int(x) times
```
Each character will be repeated 0 or 1 times, depending on the random value. Since the expected value after the square root is shifted, there is a 25% probability that each character is removed. 
### Alternative 5-byter
```
gÉ;4w
```
Filter the characters by a random number in [0, 4]. Due to how filtering works, I have to discard the actual character within the filter loop, which adds 1 byte.
[Answer]
# [Zsh](http://zsh.sourceforge.net/), ~~53~~ ~~41~~ 40 bytes
[Try it Online!](https://tio.run/##qyrO@P8/Lb9IIVlBQ6Vao9jKStOwVlNDI8jRz8XfV9VEU1NNraAoM68kTUEl@f///0GJBYnJmfmlxQpuqTmZeakKzvl5xaW5qcUKHvm5qeX5RdmKAA)
```
for c (${(s::)1})((RANDOM%4))&&printf $c
```
Converts the input to an array of characters, then tries to print each element `c`, unless it's eaten by the `((RANDOM%4))` evaluating to false!
*~~[53 bytes](https://tio.run/##qyrO@P8/Lb9IQUPDOtNGRdnQOlNbW1OzWkMjyNHPxd9X1cTOQFNTTS01OSNfQUml2jA6M7Y2JlnJuvb///9BiQWJyZn5pcUKbqk5mXmpCs75ecWluanFCh75uanl@UXZigA)~~, Original*
 *~~[41 bytes](https://tio.run/##qyrO@P8/Lb9IIVlBQ6Vao9jKStOwVlNDI8jRz8XfV9VEU1NNLTU5I19BJTkmJvn///9BiQWJyZn5pcUKbqk5mXmpCs75ecWluanFCh75uanl@UXZigA)~~, thanks to @GammaFunction*
[Answer]
# [GFortran](https://gcc.gnu.org/fortran/), 120 bytes
Not too bad, if we use the deprecated [`RAN()`](https://gcc.gnu.org/onlinedocs/gfortran/RAN.html#RAN) function, which is **pseudo**-random, i.e. you get the same sequence each time. The proper way to generate random numbers in GFortran is with `CALL RANDOM_SEED()` and `CALL RANDOM_NUMBER(R)` but that's a lot of bytes!
```
character(99)S;read(*,'(A)')S;do i=1,len_trim(S)
if(ran(0)*5.gt.1)then;write(*,'(A)',advance="no")S(i:i)
endif;enddo;end
```
[Try it online!](https://tio.run/##NYuxDoIwFAB3vqKy0BIkMjggYTAmxlk@wLy0r/AitOZR5PMrxrhc7oazngOD2/f2JzHqARh0QJZ1rbqGEYzMi0yeVbal8YLaqhjRPQLTJDuVkJXbKA8qP5Z9KCsVBnTNyhTwPxZg3uA0tqnzqeoknUgl6AzZZqPxX8Z4hxdo8sssrjiSQ3Hxbl4mnMXNT7h6fu4@)
[Answer]
# Oracle SQL, 133 bytes
```
select listagg(decode(sign(dbms_random.value-0.2),1,substr(x,level,1)))within group(order by level)from t connect by level<=length(x)
```
It works with an assumption that input data is stored in a table t(x), e.g.
```
with t(x) as (select 'The cat ate my homework' from dual)
```
]