Bu CR sorusundan esinlenmiştir ^{(lütfen CR'ye göz attığınız için beni öldürmeyin)}

spec

Bir kelimeyi yanlış yazmanın olasılıkları:

• Zamanın 1 / 3'ü çıktıyı değiştirmez
• 1/3 zaman rastgele bir karakter kaldırmak
• Zamanın 1 / 3'ü rastgele bir karakter kopyalıyor

Girişte belirli bir karakteri kaldırma / çoğaltma şansı, tüm karakterlerde aynı olmalıdır.

Birbirini takip eden iki karakter aynı ise (büyük / küçük harfe duyarlı), bunlardan birinin değiştirilme olasılığı bir karakter gibi aynı olmalıdır. Yani AA( AAya Ada ya da AAA) çıktılarının tümü aynı olasılığa sahip olmalıdır.

Girişte yalnızca basitlik için harfler bulunur.

Örnekler

İlk satır girilir, aşağıdaki satırların tümü olası yazım hatalarıdır. Her satırın çıkış olasılığı aynı olmalı, giriş örneklerde hariç tutulmalı, ancak yine de 1/3 çıkış olasılığı olmalıdır.

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

Pip , 38 27 bayt

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

Bu eğlenceliydi - Pip'in bir süredir çekmediği regex ve değişken dize yeteneklerini kullanmalıydım. Komut satırı bağımsız değişkeni ile girdi alır.

Açıklama:

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

Çevrimiçi deneyin!

Yakut, 64 55 + 1 ( pbayrak) = 56 bayt

Girdi, son satırsonu olmadan girilen bir STDIN hattıdır.

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

CJam (21 bayt)

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

Çevrimiçi demo

teşrih

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

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

Ölçek

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 bayt

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

Test edilmemiş ve test durumları:

Burada deneyin.

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

Olası çıktı:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

Python 2, 134 bayt

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)

Döngüdeki beyaz boşluklar sekmelerdir.

Ideone üzerinde deneyin

Pyth - 17 bayt

Bu aslında ardışık karakterli özel durumları doğru şekilde işler.

 XZOKrz8Or_1 2r9K

Test Takımı .

APL, 21

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

Bu, 1 rastgele konumda sıfırlardan oluşan bir vektör oluşturarak başlar. Daha sonra 1 ve 3 arasında rastgele bir sayı ile çarpar. +1 ve mod 3, 1'lerin tümü ve 0,1 veya 2 rastgele bir konumlandırılmış bir vektör elde eder.

Son olarak, ⍵ / ⍨ her harfin n kez yazılması gerektiğini belirtir, burada n vektördeki sayılardır.

Tryapl.org adresinde deneyin

Python 2, 123 bayt

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 bayt

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

Açıklama:

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

Ölçek:

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