Inspiriert von dieser CR-Frage ^{(bitte töte mich nicht, wenn ich CR durchstöbere)}

Spec

Die Wahrscheinlichkeiten für einen Rechtschreibfehler sind:

• 1/3 der Zeit ändert sich nicht die Ausgabe
• 1/3 der Zeit entfernt ein zufälliges Zeichen
• 1/3 der Zeit dupliziert ein zufälliges Zeichen

Die Chance, ein bestimmtes Zeichen in der Eingabe zu entfernen / zu duplizieren, sollte für alle Zeichen gleich sein.

Wenn zwei aufeinanderfolgende Zeichen gleich sind (Groß- und Kleinschreibung beachten), sollte die Wahrscheinlichkeit, dass eines von ihnen geändert wird, so sein, als ob es sich um ein Zeichen handelt. Dh die Ausgänge für AA(die AAoder Aoder sind AAA) sollten alle die gleiche Wahrscheinlichkeit haben.

Die Eingabe enthält der Einfachheit halber nur Buchstaben.

Beispiele

Die erste Zeile wird eingegeben, die folgenden Zeilen sind mögliche Rechtschreibfehler. Jede Zeile sollte die gleiche Ausgabewahrscheinlichkeit haben, die Eingabe wird in den Beispielen ausgeschlossen, sollte jedoch eine Ausgabewahrscheinlichkeit von 1/3 haben.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Pip , 38 27 Bytes

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

Das hat Spaß gemacht - ich musste Pips Regex und veränderbare String-Fähigkeiten verwenden, die ich eine Weile nicht mehr herausgezogen hatte. Übernimmt die Eingabe über das Befehlszeilenargument.

Erläuterung:

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

Probieren Sie es online!

Ruby, 64 55 + 1 ( pFlag) = 56 Bytes

Input ist eine Zeile von STDIN, die ohne Zeilenumbruch eingespeist wird.

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

CJam (21 Bytes)

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

Online-Demo

Präparation

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

Weniger golfen

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

Prüfung

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

Ungolfed & Testfälle:

Probieren Sie es hier aus.

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

Mögliche Ausgabe:

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)

Leerzeichen in der for-Schleife sind Tabulatoren.

Probieren Sie es auf Ideone

Pyth - 17 Bytes

Dieser behandelt die Sonderfälle mit fortlaufenden Zeichen tatsächlich korrekt.

 XZOKrz8Or_1 2r9K

Test Suite .

APL, 21

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

Dies beginnt mit der Erzeugung eines Nullvektors mit einer 1 in zufälliger Position. Dann multipliziert man es mit einer Zufallszahl zwischen 1 und 3. +1 und mod 3 erhält einen Vektor mit allen Einsen und einer zufälligen Position von 0,1 oder 2.

Schließlich sagt ⍵ / ⍨, dass jeder Buchstabe n-mal geschrieben werden sollte, wobei n die Zahlen im Vektor sind.

Probieren Sie es auf 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+(⍳=?)⍴⍵}

Erläuterung:

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

Prüfung:

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