Inspirado por esta pergunta de CR ^{(por favor, não me mate por navegar por CR)}

Spec

As probabilidades de escrever incorretamente uma palavra são:

• 1/3 do tempo não altera a saída
• 1/3 do tempo remove um caractere aleatório
• 1/3 do tempo duplicam um caracter aleatório

A chance de remover / duplicar um determinado caractere na entrada deve ser a mesma para todos os caracteres.

Se dois caracteres consecutivos forem iguais (diferencia maiúsculas de minúsculas), a probabilidade de um deles ser modificado deve ser a mesma que se fosse um caractere. Ou seja, as saídas para AA(que são AAou Aou AAA) devem ter a mesma probabilidade.

A entrada conterá apenas letras para simplificar.

Exemplos

A primeira linha é inserida, as seguintes linhas são todos os erros ortográficos possíveis. Cada linha deve ter a mesma probabilidade de saída, a entrada é excluída nos exemplos, mas ainda deve ter uma probabilidade de saída 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

Isso foi divertido - usei o regex de Pip e os recursos de seqüência de caracteres mutáveis, que eu não fazia muito tempo. Recebe entrada via argumento da linha de comando.

Explicação:

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

Experimente online!

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

Entrada é uma linha de STDIN inserida sem linha nova à direita.

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

CJam (21 bytes)

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

Demonstração online

Dissecação

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 golfe

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``
)

Teste

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);}

Casos não testados e de teste:

Experimente aqui.

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"));
    }
  }
}

Saída possível:

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)

Os espaços em branco no loop for são guias.

Experimente no Ideone

Pitão - 17 bytes

Este realmente lida com casos especiais com caracteres consecutivos corretamente.

 XZOKrz8Or_1 2r9K

Conjunto de Teste .

APL, 21

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

Isso começa criando um vetor de zeros com um 1 em posição aleatória. Em seguida, multiplica-o por um número aleatório entre 1 e 3. +1 e mod 3 obtém um vetor com todos os 1s e um aleatório posicionado 0,1 ou 2.

Finalmente, ⍵ / ⍨ diz que cada letra deve ser escrita n vezes, onde n são os números do vetor.

Experimente em 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+(⍳=?)⍴⍵}

Explicação:

                        ⍴⍵  ⍝ 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 ⍵

Teste:

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