Lấy cảm hứng từ câu hỏi CR này ^{(xin đừng giết tôi để duyệt CR)}

Thông số kỹ thuật

Xác suất sai chính tả của một từ là:

• 1/3 thời gian không thay đổi đầu ra
• 1/3 thời gian loại bỏ một ký tự ngẫu nhiên
• 1/3 thời gian nhân đôi một ký tự ngẫu nhiên

Cơ hội để loại bỏ / sao chép một ký tự đã cho trong đầu vào phải giống nhau cho tất cả các ký tự.

Nếu hai ký tự liên tiếp giống nhau (phân biệt chữ hoa chữ thường), xác suất một trong số chúng được sửa đổi sẽ giống như thể chúng là một ký tự. Tức là đầu ra cho AA(mà là AAhay Ahay AAA) tất cả nên có khả năng tương tự.

Đầu vào sẽ chỉ chứa các chữ cái cho đơn giản.

Ví dụ

Dòng đầu tiên là đầu vào, các dòng sau là tất cả các lỗi chính tả. Mỗi dòng nên có cùng xác suất là đầu ra, đầu vào được loại trừ trong các ví dụ nhưng nó vẫn phải có xác suất đầu ra là 1/3.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Pip , 38 27 byte

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

Điều này thật thú vị - đã sử dụng regex và các khả năng chuỗi có thể thay đổi của Pip, điều mà tôi đã không rút ra được trong một thời gian. Đưa đầu vào thông qua đối số dòng lệnh.

Giải trình:

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

Hãy thử trực tuyến!

Ruby, 64 55 + 1 ( pcờ) = 56 byte

Đầu vào là một dòng STDIN được dẫn vào mà không theo dõi dòng mới.

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

CJam (21 byte)

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

Bản demo trực tuyến

Mổ xẻ

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

Ít chơi gôn

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

Kiểm tra

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

Các trường hợp bất ngờ & thử nghiệm:

Hãy thử nó ở đây.

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

Sản lượng có thể:

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)

Khoảng trắng trong vòng lặp là các tab.

Hãy thử nó trên Ideone

Pyth - 17 byte

Điều này thực sự xử lý các trường hợp đặc biệt với char liên tiếp chính xác.

 XZOKrz8Or_1 2r9K

Phòng thử nghiệm .

APL, 21

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

Điều này bắt đầu bằng cách tạo một vectơ số không với 1 ở vị trí ngẫu nhiên. Sau đó nhân nó với một số ngẫu nhiên trong khoảng từ 1 đến 3. +1 và mod 3 thu được một vectơ với tất cả 1 và một vị trí ngẫu nhiên 0,1 hoặc 2.

Cuối cùng, / nói rằng mỗi chữ cái nên được viết n lần, trong đó n là các số trong vectơ.

Dùng thử trên 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+(⍳=?)⍴⍵}

Giải trình:

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

Kiểm tra:

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