Натхненний цим питанням CR ^{(будь ласка, не вбивайте мене за перегляд CR)}

Спец

Ймовірність неправильного написання слова:

• 1/3 часу не змінюють вихід
• 1/3 часу видаліть випадковий символ
• 1/3 часу дублює випадковий символ

Шанс для видалення / дублювання заданого символу у вхідному сигналі повинен бути однаковим для всіх символів.

Якщо два послідовних символи однакові (залежно від регістру), ймовірність зміни одного з них повинна бути такою ж, як якщо б вони були одним символом. Тобто виходи для AA(які є AAабо Aчи AAA) всі повинні мати однакову ймовірність.

Вхід буде містити лише літери для простоти.

Приклади

Перший рядок вводиться, наступні рядки - це всі можливі неправильні написання. Кожен рядок повинен мати однакову ймовірність виведення, вхідний приклад виключений у прикладах, але він все одно повинен мати 1/3 ймовірності виведення.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Піп , 38 27 байт

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

Це було весело - я мав використовувати функції регексу та змінних рядків Піпа, які я не витягував задовго. Здійснює введення через аргумент командного рядка.

Пояснення:

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

Спробуйте в Інтернеті!

Ruby, 64 55 + 1 ( pпрапор) = 56 байт

Вхід - це лінія STDIN, прокладена без затримки нового рядка.

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

CJam (21 байт)

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

Демонстрація в Інтернеті

Розсічення

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

Менше гольфу

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

Тест

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 байт

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

Невикористані та тестові справи:

Спробуйте тут.

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

Можливий вихід:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

Пітон 2, 134 байти

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)

Білі пробіли для циклу - це вкладки.

Спробуйте це на Ideone

Pyth - 17 байт

Цей фактично правильно обробляє спеціальні випадки з послідовними символами.

 XZOKrz8Or_1 2r9K

Тестовий сюїт .

APL, 21

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

Це починається зі створення вектора нулів з 1 у випадковому положенні. Потім множимо його на випадкове число між 1 і 3. +1 і mod 3 отримує вектор з усіма 1s і одним випадковим розташуванням 0,1 або 2.

Нарешті, ⍵ / ⍨ говорить, що кожну букву слід писати n разів, де n - числа у векторі.

Спробуйте це на tryapl.org

Python 2, 123 байт

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 байт

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

Пояснення:

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

Тест:

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