Inspiré par cette question CR ^{(veuillez ne pas me tuer pour avoir parcouru CR)}

Spec

Les probabilités d'orthographe d'un mot sont les suivantes:

• 1/3 du temps ne change pas la sortie
• 1/3 du temps supprime un caractère aléatoire
• 1/3 du temps dupliquer un caractère aléatoire

La possibilité de supprimer / dupliquer un caractère donné dans l'entrée doit être la même pour tous les caractères.

Si deux caractères consécutifs sont identiques (sensibles à la casse), la probabilité que l'un d'entre eux soit modifié doit être la même que s'il s'agit d'un seul caractère. C'est-à-dire que les sorties pour AA(qui sont AAou Aou AAA) devraient toutes avoir la même probabilité.

L'entrée ne contiendra que des lettres pour plus de simplicité.

Exemples

La première ligne est entrée, les lignes suivantes sont toutes des fautes d'orthographe possibles. Chaque ligne doit avoir la même probabilité d'être sortie, l'entrée est exclue dans les exemples mais elle doit toujours avoir une probabilité 1/3 de sortie.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Pip , 38 27 octets

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

C'était amusant - j'ai pu utiliser les capacités de regex et de chaîne mutable de Pip, que je n'avais pas retirées depuis longtemps. Prend l'entrée via l'argument de ligne de commande.

Explication:

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

Essayez-le en ligne!

Ruby, 64 55 + 1 ( pindicateur) = 56 octets

L'entrée est une ligne de STDIN canalisée sans retour à la ligne.

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

CJam (21 octets)

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

Démo en ligne

Dissection

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

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

Tester

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 octets

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

Cas non testés et testés:

Essayez-le ici.

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

Sortie possible:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

Python 2, 134 octets

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)

Les espaces blancs dans la boucle sont des tabulations.

Essayez-le sur Ideone

Pyth - 17 octets

Celui-ci gère correctement les cas spéciaux avec des caractères consécutifs.

 XZOKrz8Or_1 2r9K

Suite de tests .

APL, 21

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

Cela commence par créer un vecteur de zéros avec un 1 en position aléatoire. Multiplie ensuite par un nombre aléatoire entre 1 et 3. +1 et le mod 3 obtient un vecteur avec tous les 1 et un 0,1 ou 2 positionné au hasard.

Enfin, ⍵ / ⍨ dit que chaque lettre doit être écrite n fois, où n sont les nombres du vecteur.

Essayez-le sur tryapl.org

Python 2, 123 octets

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 octets

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

Explication:

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

Tester:

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