Inspirado por esta pregunta de CR ^{(por favor no me mates por navegar por CR)}

Especificaciones

Las probabilidades de escribir mal una palabra son:

• 1/3 del tiempo no cambia la salida
• 1/3 de las veces elimina un personaje aleatorio
• 1/3 del tiempo duplica un carácter aleatorio

La posibilidad de eliminar / duplicar un carácter dado en la entrada debe ser la misma para todos los caracteres.

Si dos caracteres consecutivos son iguales (distingue entre mayúsculas y minúsculas), la probabilidad de que uno de ellos se modifique debería ser la misma que si fueran un solo carácter. Es decir, las salidas para AA(que son AAo Ao AAA) todo debe tener la misma probabilidad.

La entrada solo contendrá letras para simplificar.

Ejemplos

La primera línea es de entrada, las siguientes líneas son todos los errores ortográficos posibles. Cada línea debe tener la misma probabilidad de salida, la entrada se excluye en los ejemplos pero aún debe tener una probabilidad de salida de 1/3.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Pip , 38 27 bytes

a@:`(.)\1*`YRR#aa@y@0X:RR3a

Esto fue divertido: pude usar las capacidades de expresión regular y cadena mutable de Pip, que no había sacado en mucho tiempo. Toma entrada a través de la línea de comando argumento.

Explicación:

a@:`(.)\1*`                  Split a into runs of identical chars using regex match
           YRR#a             Yank randrange(len(a)) into y (randomly choosing one such run)
                a@y@0        Take the first character of that run
                     X:RR3   Modify in place, string-multiplying by randrange(3):
                               If RR3 is 0, character is deleted
                               If RR3 is 1, no change
                               If RR3 is 2, character is duplicated
                          a  Output the modified a

Pruébalo en línea!

Ruby, 64 55 + 1 ( pbandera) = 56 bytes

La entrada es una línea de STDIN canalizada sin una nueva línea final.

a=[]
gsub(/(.)\1*/){a<<$&}
a.sample[-1]*=rand 3
$_=a*''

CJam (21 bytes)

re`_,mr_2$=3mr(a.+te~

Demostración en línea

Disección

r     e# Read a line of input from stdin
e`    e# Run-length encode it
_,mr  e# Select a random index in the RLE array
_     e# Hang on to a copy of that index
2$=   e# Copy the [run-length char] pair from that index
3mr(  e# Select a uniformly random integer from {-1, 0, 1}
a.+   e# Add it to the run-length
t     e# Replace the pair at that index
e~    e# Run-length decode

JavaScript (ES6), 107

w=>(r=x=>Math.random()*x|0,a=w.match(/(.)\1*/g),a[p=r(a.length)]=[b=a[p],b+b[0],b.slice(1)][r(3)],a.join``)

Menos golf

w=>(
  a = w.match(/(.)\1*/g),
  r = x => Math.random()*x | 0,
  p = r(a.length),
  b = a[p],
  a[p] = [b, b+b[0], b.slice(1)][r(3)],
  a.join``
)

Prueba

f=w=>(r=x=>Math.random()*x|0,a=w.match(/(.)\1*/g),a[p=r(a.length)]=[b=a[p],b+b[0],b.slice(1)][r(3)],a.join``)

function update() { 
  O.innerHTML = Array(99)
  .fill(I.value)
  .map(x=>(
    r=f(x),
    r==x?r:r.length<x.length?'<b>'+r+'</b>':'<i>'+r+'</i>'
  
    )
  ).join` `
}

update()

#O { width:90%; overflow: auto; white-space: pre-wrap}

<input id=I oninput='update()' value='trolley'><pre id=O></pre>

Java 7, 189 180 178 bytes

import java.util.*;String c(String i){Random r=new Random();int x=r.nextInt(2),j=r.nextInt(i.length());return x<1?i:i.substring(0,j-(x%2^1))+(x<2?i.charAt(j):"")+i.substring(j);}

Sin golf y casos de prueba:

Pruébalo aquí

import java.util.*;
class M{
  static String c(String i){
    Random r = new Random();
    int x = r.nextInt(2),
        j = r.nextInt(i.length());
    return x < 1
            ? i
            : i.substring(0, j - (x%2 ^ 1)) + (x<2?i.charAt(j):"") + i.substring(j);
  }

  public static void main(String[] a){
    for(int i = 0; i < 5; i++){
      System.out.println(c("foo"));
    }
    System.out.println();
    for(int i = 0; i < 5; i++){
      System.out.println(c("PPCG"));
    }
  }
}

Salida posible:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

Python 2, 134 bytes

from random import*
def f(s):
 p=c=0;M,L=[],list(s)
 for t in L:
  if t!=p:M+=c,;p=t
  c+=1
 L[choice(M)]*=randint(0,2);return''.join(L)

Los espacios en blanco en for loop son pestañas.

Pruébalo en Ideone

Pyth - 17 bytes

Este realmente maneja los casos especiales con caracteres consecutivos correctamente.

 XZOKrz8Or_1 2r9K

Test Suite .

APL, 21

{⍵/⍨3|1+(?3)×(⍳=?)⍴⍵}

Esto comienza creando un vector de ceros con un 1 en posición aleatoria. Luego, multiplíquelo por un número aleatorio entre 1 y 3. +1 y mod 3 obtiene un vector con todos los 1 y uno aleatorio colocado 0,1 o 2.

Finalmente, ⍵ / ⍨ dice que cada letra debe escribirse n veces, donde n son los números en el vector.

Pruébalo en tryapl.org

Python 2, 123 bytes

from random import*
R=randint
s=input()
m=n=R(0,len(s)-1)
c=R(0,2)
m=[m,1+[-len(s),m][m>0]][c==1]
n+=c==2
print s[:m]+s[n:]

JavaScript (ES6), 103

w=>{w=w.split(''),r=Math.random,x=r(),i=r()*w.length|0;w.splice(i,x<.6,x>.3?w[i]:'');alert(w.join(''))}

APL, 27 bytes

{⍵/⍨(?3)⌷1⍪2 0∘.|1+(⍳=?)⍴⍵}

Explicación:

                        ⍴⍵  ⍝ length of ⍵
                   (⍳=?)    ⍝ bit vector with one random bit on 
                 1+         ⍝ add one to each value (duplicate one character)
           2 0∘.|           ⍝ mod by 2 and 0 (remove instead of duplicate)
         1⍪                 ⍝ add a line of just ones (do nothing)
    (?3)⌷                   ⍝ select a random line from that matrix
 ⍵/⍨                        ⍝ replicate characters in ⍵

Prueba:

      {⍵/⍨(?3)⌷1⍪2 0∘.|1+(⍳=?)⍴⍵} ¨ 10/⊂'foo'
 fooo  foo  oo  foo  fo  fo  oo  fo  oo  fooo