Ispirato da questa domanda CR ^{(per favore, non uccidermi per aver cercato CR)}

Spec

Le probabilità di scrivere male una parola sono:

• 1/3 del tempo non modifica l'output
• 1/3 del tempo rimuove un personaggio casuale
• 1/3 del tempo duplica un personaggio casuale

La possibilità di rimuovere / duplicare un determinato carattere nell'input dovrebbe essere la stessa per tutti i caratteri.

Se due caratteri consecutivi sono uguali (distinzione tra maiuscole e minuscole), la probabilità che uno di essi venga modificato dovrebbe essere uguale a quella di un carattere. Vale a dire le uscite per AA(che sono AAo Ao AAA) dovrebbero avere tutte la stessa probabilità.

L'input conterrà solo lettere per semplicità.

Esempi

Viene immessa la prima riga, le seguenti righe sono tutti possibili errori di ortografia. Ogni riga dovrebbe avere la stessa probabilità di essere emessa, l'ingresso è escluso negli esempi ma dovrebbe comunque avere una probabilità 1/3 di uscita.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

seme , 38 27 byte

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

È stato divertente - ho usato la regex di Pip e le capacità di stringa mutabili, che non avevo tirato fuori da un po '. Accetta input tramite argomento della riga di comando.

Spiegazione:

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

Provalo online!

Rubino, 64 55 + 1 ( pbandiera) = 56 byte

L'input è una linea di STDIN convogliata senza trascinare la nuova riga.

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

CJam (21 byte)

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

Demo online

Dissezione

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

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

Test

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 byte

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

Casi non testati e test:

Provalo qui.

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

Uscita possibile:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

Python 2, 134 byte

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)

Gli spazi bianchi in for loop sono schede.

Provalo su Ideone

Pyth - 17 byte

Questo in realtà gestisce correttamente i casi speciali con caratteri consecutivi.

 XZOKrz8Or_1 2r9K

Test Suite .

APL, 21

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

Questo inizia creando un vettore di zeri con un 1 in posizione casuale. Quindi lo moltiplica per un numero casuale compreso tra 1 e 3. +1 e mod 3 ottiene un vettore con tutti 1 e un casuale posizionato 0,1 o 2.

Infine, ⍵ / ⍨ dice che ogni lettera dovrebbe essere scritta n volte, dove n sono i numeri nel vettore.

Provalo su tryapl.org

Python 2, 123 byte

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 byte

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

Spiegazione:

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

Test:

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