Zainspirowany tym pytaniem CR ^{(proszę nie zabijaj mnie za przeglądanie CR)}

Spec

Prawdopodobieństwa błędnej pisowni słowa to:

• 1/3 czasu nie zmienia wyniku
• 1/3 czasu usuwa losową postać
• 1/3 czasu duplikuje losową postać

Szansa na usunięcie / zduplikowanie danego znaku na wejściu powinna być taka sama dla wszystkich znaków.

Jeśli dwa kolejne znaki są takie same (rozróżnia małe i wielkie litery), prawdopodobieństwo modyfikacji jednego z nich powinno być takie samo, jak gdyby były jednym znakiem. To znaczy, że wyniki dla AA(które są AAlub Alub AAA) powinny mieć takie samo prawdopodobieństwo.

Wprowadzanie będzie zawierać tylko litery dla uproszczenia.

Przykłady

Wprowadzany jest pierwszy wiersz, kolejne wiersze to wszystkie możliwe błędy ortograficzne. Każda linia powinna mieć takie samo prawdopodobieństwo wyjścia, dane wejściowe są wykluczone w przykładach, ale nadal powinno mieć 1/3 prawdopodobieństwa wyjścia.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Pip , 38 27 bajtów

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

To była frajda - skorzystałem z możliwości wyrażania regularnego Pipa i zmiennych ciągów, których od dłuższego czasu nie wyciągałem. Pobiera dane wejściowe za pomocą argumentu wiersza polecenia.

Wyjaśnienie:

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

Wypróbuj online!

Ruby, 64 55 + 1 ( pflaga) = 56 bajtów

Dane wejściowe są wprowadzane do linii STDIN bez końca nowej linii.

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

CJam (21 bajtów)

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

Demo online

Sekcja

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

Mniej golfa

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 bajtów

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

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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

Możliwe wyjście:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

Python 2, 134 bajty

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)

Białe spacje w pętli for to tabulatory.

Wypróbuj na Ideone

Pyth - 17 bajtów

Ten faktycznie właściwie obsługuje specjalne przypadki z kolejnymi znakami.

 XZOKrz8Or_1 2r9K

Pakiet testowy .

APL, 21

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

Zaczyna się to od utworzenia wektora zer z 1 w losowej pozycji. Następnie mnoży go przez losową liczbę od 1 do 3. +1 i mod 3 uzyskuje wektor ze wszystkimi 1s i jedną losową pozycją 0,1 lub 2.

Wreszcie ⍵ / ⍨ mówi, że każdą literę należy pisać n razy, gdzie n to liczby w wektorze.

Wypróbuj na tryapl.org

Python 2, 123 bajty

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 bajtów

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

Wyjaśnienie:

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